ghc 8.2.2 → 8.4.1
raw patch · 520 files changed
+48168/−37167 lines, 520 filesdep −hoopldep ~Win32dep ~basedep ~ghc-bootPVP ok
version bump matches the API change (PVP)
Dependencies removed: hoopl
Dependency ranges changed: Win32, base, ghc-boot, ghc-boot-th, ghci, template-haskell
API changes (from Hackage documentation)
- BasicTypes: EmptyInlineSpec :: InlineSpec
- BasicTypes: isEmptyInlineSpec :: InlineSpec -> Bool
- BlockId: instance Outputable.Outputable BlockId.BlockId
- BlockId: instance Unique.Uniquable BlockId.BlockId
- BuildTyCl: mkDataConUnivTyVarBinders :: [TyConBinder] -> [TyVarBinder]
- CLabel: instance GHC.Classes.Eq CLabel.CaseLabelInfo
- CLabel: instance GHC.Classes.Ord CLabel.CaseLabelInfo
- CLabel: maybeAsmTemp :: CLabel -> Maybe Unique
- CLabel: mkAltLabel :: Unique -> ConTag -> CLabel
- CLabel: mkCAFBlackHoleEntryLabel :: CLabel
- CLabel: mkConEntryLabel :: Name -> CafInfo -> CLabel
- CLabel: mkDefaultLabel :: Unique -> CLabel
- CLabel: mkEMPTY_MVAR_infoLabel :: CLabel
- CLabel: mkLocalConEntryLabel :: CafInfo -> Name -> CLabel
- CLabel: mkLocalConInfoTableLabel :: CafInfo -> Name -> CLabel
- CLabel: mkLocalEntryLabel :: Name -> CafInfo -> CLabel
- CLabel: mkPlainModuleInitLabel :: Module -> CLabel
- CLabel: mkReturnInfoLabel :: Unique -> CLabel
- CLabel: mkReturnPtLabel :: Unique -> CLabel
- CLabel: mkSRTLabel :: Name -> CafInfo -> CLabel
- CLabel: mkSlowEntryLabel :: Name -> CafInfo -> CLabel
- CLabel: toRednCountsLbl :: CLabel -> Maybe CLabel
- Class: naturallyCoherentClass :: Class -> Bool
- Cmm: type CmmBwdRewrite f = BwdRewrite UniqSM CmmNode f
- Cmm: type CmmFwdRewrite f = FwdRewrite UniqSM CmmNode f
- Cmm: type CmmReplGraph e x = GenCmmReplGraph CmmNode e x
- Cmm: type GenCmmReplGraph n e x = UniqSM (Maybe (Graph n e x))
- CmmNode: instance Compiler.Hoopl.Graph.NonLocal CmmNode.CmmNode
- Coercion: pprCoBndr :: Name -> Coercion -> SDoc
- CoreFVs: data FVAnn
- CoreFVs: exprTypeFV :: CoreExprWithFVs -> Type
- CoreFVs: freeVarsOfType :: CoreExprWithFVs -> DTyCoVarSet
- CoreFVs: freeVarsOfTypeAnn :: FVAnn -> DTyCoVarSet
- CoreMonad: data SimplifierMode
- CoreMonad: instance Outputable.Outputable CoreMonad.SimplifierMode
- CoreToStg: coreExprToStg :: CoreExpr -> StgExpr
- CoreUtils: exprIsOk :: CheapAppFun -> CoreExpr -> Bool
- CostCentre: noCCS :: CostCentreStack
- CostCentre: noCCSAttached :: CostCentreStack -> Bool
- DataCon: dataConAllTyVars :: DataCon -> [TyVar]
- DataCon: dataConExTyVarBinders :: DataCon -> [TyVarBinder]
- DataCon: dataConUnivTyVarBinders :: DataCon -> [TyVarBinder]
- Demand: instance (GHC.Classes.Eq u, GHC.Classes.Eq s) => GHC.Classes.Eq (Demand.JointDmd s u)
- Demand: instance (GHC.Show.Show u, GHC.Show.Show s) => GHC.Show.Show (Demand.JointDmd s u)
- Digraph: type Node key payload = (payload, key, [key])
- DriverPipeline: mkExtraObjToLinkIntoBinary :: DynFlags -> IO FilePath
- DriverPipeline: mkNoteObjsToLinkIntoBinary :: DynFlags -> [InstalledUnitId] -> IO [FilePath]
- DynFlags: [dllSplitFile] :: DynFlags -> Maybe FilePath
- DynFlags: [dllSplit] :: DynFlags -> Maybe [Set String]
- DynFlags: [filesToNotIntermediateClean] :: DynFlags -> IORef [FilePath]
- DynFlags: [rtsBuildTag] :: DynFlags -> String
- ErrUtils: warnIsErrorMsg :: DynFlags -> ErrMsg
- FamInst: checkRecFamInstConsistency :: TyCon -> TcM ()
- FamInst: instance GHC.Classes.Eq FamInst.ModulePair
- FamInst: instance GHC.Classes.Ord FamInst.ModulePair
- FamInst: instance Outputable.Outputable FamInst.ModulePair
- FamInstEnv: pmTopNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe (Type, [DataCon], Type)
- GHC: [dllSplitFile] :: DynFlags -> Maybe FilePath
- GHC: [dllSplit] :: DynFlags -> Maybe [Set String]
- GHC: [filesToNotIntermediateClean] :: DynFlags -> IORef [FilePath]
- GHC: [rtsBuildTag] :: DynFlags -> String
- GHC: needsTemplateHaskell :: ModuleGraph -> Bool
- GHC: type ModuleGraph = [ModSummary]
- Hoopl: instance Outputable.Outputable Compiler.Hoopl.Label.LabelSet
- Hoopl: instance Outputable.Outputable a => Outputable.Outputable (Compiler.Hoopl.Label.LabelMap a)
- HsBinds: AbsBindsSig :: [TyVar] -> [EvVar] -> idL -> TcSpecPrags -> TcEvBinds -> LHsBind idL -> HsBindLR idL idR
- HsBinds: InfixPatSyn :: a -> a -> HsPatSynDetails a
- HsBinds: PrefixPatSyn :: [a] -> HsPatSynDetails a
- HsBinds: RecordPatSyn :: [RecordPatSynField a] -> HsPatSynDetails a
- HsBinds: [abs_sig_bind] :: HsBindLR idL idR -> LHsBind idL
- HsBinds: [abs_sig_ev_bind] :: HsBindLR idL idR -> TcEvBinds
- HsBinds: [abs_sig_export] :: HsBindLR idL idR -> idL
- HsBinds: [abs_sig_prags] :: HsBindLR idL idR -> TcSpecPrags
- HsBinds: data HsPatSynDetails a
- HsBinds: instance (Outputable.OutputableBndr idL, PlaceHolder.OutputableBndrId idR) => Outputable.Outputable (HsBinds.PatSynBind idL idR)
- HsBinds: instance (PlaceHolder.DataId idL, PlaceHolder.DataId idR) => Data.Data.Data (HsBinds.HsBindLR idL idR)
- HsBinds: instance (PlaceHolder.DataId idL, PlaceHolder.DataId idR) => Data.Data.Data (HsBinds.HsLocalBindsLR idL idR)
- HsBinds: instance (PlaceHolder.DataId idL, PlaceHolder.DataId idR) => Data.Data.Data (HsBinds.HsValBindsLR idL idR)
- HsBinds: instance (PlaceHolder.DataId idL, PlaceHolder.DataId idR) => Data.Data.Data (HsBinds.PatSynBind idL idR)
- HsBinds: instance (PlaceHolder.OutputableBndrId idL, PlaceHolder.OutputableBndrId idR) => Outputable.Outputable (HsBinds.HsBindLR idL idR)
- HsBinds: instance (PlaceHolder.OutputableBndrId idL, PlaceHolder.OutputableBndrId idR) => Outputable.Outputable (HsBinds.HsLocalBindsLR idL idR)
- HsBinds: instance (PlaceHolder.OutputableBndrId idL, PlaceHolder.OutputableBndrId idR) => Outputable.Outputable (HsBinds.HsValBindsLR idL idR)
- HsBinds: instance Data.Data.Data a => Data.Data.Data (HsBinds.HsPatSynDetails a)
- HsBinds: instance Data.Data.Data id => Data.Data.Data (HsBinds.ABExport id)
- HsBinds: instance Data.Data.Data name => Data.Data.Data (HsBinds.FixitySig name)
- HsBinds: instance Data.Foldable.Foldable HsBinds.HsPatSynDetails
- HsBinds: instance Data.Traversable.Traversable HsBinds.HsPatSynDetails
- HsBinds: instance GHC.Base.Functor HsBinds.HsPatSynDetails
- HsBinds: instance Outputable.OutputableBndr id => Outputable.Outputable (HsBinds.ABExport id)
- HsBinds: instance Outputable.OutputableBndr name => Outputable.Outputable (HsBinds.FixitySig name)
- HsBinds: instance PlaceHolder.DataId id => Data.Data.Data (HsBinds.HsIPBinds id)
- HsBinds: instance PlaceHolder.DataId id => Data.Data.Data (HsBinds.HsPatSynDir id)
- HsBinds: instance PlaceHolder.DataId name => Data.Data.Data (HsBinds.IPBind name)
- HsBinds: instance PlaceHolder.DataId name => Data.Data.Data (HsBinds.Sig name)
- HsBinds: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsBinds.HsIPBinds id)
- HsBinds: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsBinds.IPBind id)
- HsBinds: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsBinds.Sig name)
- HsDecls: TyFamEqn :: Located name -> pats -> LexicalFixity -> LHsType name -> TyFamEqn name pats
- HsDecls: [dfid_defn] :: DataFamInstDecl name -> HsDataDefn name
- HsDecls: [dfid_fixity] :: DataFamInstDecl name -> LexicalFixity
- HsDecls: [dfid_fvs] :: DataFamInstDecl name -> PostRn name NameSet
- HsDecls: [dfid_pats] :: DataFamInstDecl name -> HsTyPats name
- HsDecls: [dfid_tycon] :: DataFamInstDecl name -> Located name
- HsDecls: [tfe_fixity] :: TyFamEqn name pats -> LexicalFixity
- HsDecls: [tfe_pats] :: TyFamEqn name pats -> pats
- HsDecls: [tfe_rhs] :: TyFamEqn name pats -> LHsType name
- HsDecls: [tfe_tycon] :: TyFamEqn name pats -> Located name
- HsDecls: [tfid_fvs] :: TyFamInstDecl name -> PostRn name NameSet
- HsDecls: data DataFamInstDecl name
- HsDecls: data TyFamEqn name pats
- HsDecls: data TyFamInstDecl name
- HsDecls: instance (PlaceHolder.DataId name, Data.Data.Data pats) => Data.Data.Data (HsDecls.TyFamEqn name pats)
- HsDecls: instance Data.Data.Data name => Data.Data.Data (HsDecls.AnnProvenance name)
- HsDecls: instance Data.Data.Data name => Data.Data.Data (HsDecls.InjectivityAnn name)
- HsDecls: instance Data.Data.Data name => Data.Data.Data (HsDecls.RoleAnnotDecl name)
- HsDecls: instance Data.Data.Data name => Data.Data.Data (HsDecls.WarnDecl name)
- HsDecls: instance Data.Data.Data name => Data.Data.Data (HsDecls.WarnDecls name)
- HsDecls: instance Outputable.Outputable (HsDecls.FamilyInfo name)
- HsDecls: instance Outputable.OutputableBndr name => Outputable.Outputable (HsDecls.RoleAnnotDecl name)
- HsDecls: instance Outputable.OutputableBndr name => Outputable.Outputable (HsDecls.WarnDecl name)
- HsDecls: instance Outputable.OutputableBndr name => Outputable.Outputable (HsDecls.WarnDecls name)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.ClsInstDecl id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.FamilyDecl id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.HsDataDefn id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.HsDecl id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.HsDerivingClause id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.HsGroup id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.InstDecl id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.SpliceDecl id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.TyClDecl id)
- HsDecls: instance PlaceHolder.DataId id => Data.Data.Data (HsDecls.TyClGroup id)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.AnnDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.ConDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.DataFamInstDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.DefaultDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.DerivDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.FamilyInfo name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.FamilyResultSig name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.ForeignDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.RuleBndr name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.RuleDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.RuleDecls name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.TyFamInstDecl name)
- HsDecls: instance PlaceHolder.DataId name => Data.Data.Data (HsDecls.VectDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.AnnDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.ClsInstDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.ConDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.DataFamInstDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.DefaultDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.DerivDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.FamilyDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.ForeignDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.HsDataDefn name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.HsDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.HsDerivingClause name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.HsGroup name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.InstDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.RuleBndr name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.RuleDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.RuleDecls name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.SpliceDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.TyClDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.TyClGroup name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.TyFamInstDecl name)
- HsDecls: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsDecls.VectDecl name)
- HsExpr: [m_type] :: Match id body -> (Maybe (LHsType id))
- HsExpr: instance (Data.Data.Data body, PlaceHolder.DataId id) => Data.Data.Data (HsExpr.GRHS id body)
- HsExpr: instance (Data.Data.Data body, PlaceHolder.DataId id) => Data.Data.Data (HsExpr.GRHSs id body)
- HsExpr: instance (Data.Data.Data body, PlaceHolder.DataId id) => Data.Data.Data (HsExpr.Match id body)
- HsExpr: instance (Data.Data.Data body, PlaceHolder.DataId id) => Data.Data.Data (HsExpr.MatchGroup id body)
- HsExpr: instance (Data.Data.Data body, PlaceHolder.DataId idL, PlaceHolder.DataId idR) => Data.Data.Data (HsExpr.StmtLR idL idR body)
- HsExpr: instance (Outputable.Outputable id, Outputable.Outputable (PlaceHolder.NameOrRdrName id)) => Outputable.Outputable (HsExpr.HsStmtContext id)
- HsExpr: instance (PlaceHolder.DataId idL, PlaceHolder.DataId idR) => Data.Data.Data (HsExpr.ApplicativeArg idL idR)
- HsExpr: instance (PlaceHolder.DataId idL, PlaceHolder.DataId idR) => Data.Data.Data (HsExpr.ParStmtBlock idL idR)
- HsExpr: instance (PlaceHolder.OutputableBndrId idL, PlaceHolder.OutputableBndrId idR, Outputable.Outputable body) => Outputable.Outputable (HsExpr.StmtLR idL idR body)
- HsExpr: instance (PlaceHolder.OutputableBndrId idR, Outputable.Outputable body) => Outputable.Outputable (HsExpr.Match idR body)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.ArithSeqInfo id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.HsBracket id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.HsCmd id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.HsCmdTop id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.HsExpr id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.HsSplice id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.HsSplicedThing id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.HsTupArg id)
- HsExpr: instance PlaceHolder.DataId id => Data.Data.Data (HsExpr.SyntaxExpr id)
- HsExpr: instance PlaceHolder.DataIdPost id => Data.Data.Data (HsExpr.HsMatchContext id)
- HsExpr: instance PlaceHolder.DataIdPost id => Data.Data.Data (HsExpr.HsStmtContext id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.ArithSeqInfo id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.HsBracket id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.HsCmd id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.HsCmdTop id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.HsExpr id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.HsSplice id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.HsSplicedThing id)
- HsExpr: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsExpr.SyntaxExpr id)
- HsExpr: instance PlaceHolder.OutputableBndrId idL => Outputable.Outputable (HsExpr.ParStmtBlock idL idR)
- HsImpExp: instance (OccName.HasOccName name, Outputable.OutputableBndr name) => Outputable.Outputable (HsImpExp.IE name)
- HsImpExp: instance (OccName.HasOccName name, Outputable.OutputableBndr name) => Outputable.Outputable (HsImpExp.IEWrappedName name)
- HsImpExp: instance (Outputable.OutputableBndr name, OccName.HasOccName name) => Outputable.Outputable (HsImpExp.ImportDecl name)
- HsImpExp: instance (Outputable.OutputableBndr name, OccName.HasOccName name) => Outputable.OutputableBndr (HsImpExp.IEWrappedName name)
- HsImpExp: instance Data.Data.Data name => Data.Data.Data (HsImpExp.IE name)
- HsImpExp: instance Data.Data.Data name => Data.Data.Data (HsImpExp.ImportDecl name)
- HsImpExp: instance GHC.Classes.Eq name => GHC.Classes.Eq (HsImpExp.IE name)
- HsLit: instance Data.Data.Data HsLit.HsLit
- HsLit: instance GHC.Classes.Eq (HsLit.HsOverLit id)
- HsLit: instance GHC.Classes.Eq HsLit.HsLit
- HsLit: instance GHC.Classes.Ord (HsLit.HsOverLit id)
- HsLit: instance Outputable.Outputable HsLit.HsLit
- HsLit: instance PlaceHolder.DataId id => Data.Data.Data (HsLit.HsOverLit id)
- HsLit: instance PlaceHolder.OutputableBndrId id => Outputable.Outputable (HsLit.HsOverLit id)
- HsPat: instance (Data.Data.Data arg, Data.Data.Data id) => Data.Data.Data (HsPat.HsRecField' id arg)
- HsPat: instance (Outputable.Outputable id, Outputable.Outputable arg) => Outputable.Outputable (HsPat.HsRecField' id arg)
- HsPat: instance (PlaceHolder.DataId id, Data.Data.Data arg) => Data.Data.Data (HsPat.HsRecFields id arg)
- HsPat: instance Data.Foldable.Foldable (HsPat.HsRecFields id)
- HsPat: instance Data.Traversable.Traversable (HsPat.HsRecFields id)
- HsPat: instance GHC.Base.Functor (HsPat.HsRecFields id)
- HsPat: instance Outputable.Outputable arg => Outputable.Outputable (HsPat.HsRecFields id arg)
- HsPat: instance PlaceHolder.DataId id => Data.Data.Data (HsPat.Pat id)
- HsPat: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsPat.Pat name)
- HsPat: isBangedPatBind :: HsBind id -> Bool
- HsSyn: instance (PlaceHolder.OutputableBndrId name, OccName.HasOccName name) => Outputable.Outputable (HsSyn.HsModule name)
- HsSyn: instance PlaceHolder.DataId name => Data.Data.Data (HsSyn.HsModule name)
- HsTypes: instance (Data.Data.Data name, Data.Data.Data (PlaceHolder.PostRn name name)) => Data.Data.Data (HsTypes.FieldOcc name)
- HsTypes: instance (Data.Data.Data name, Data.Data.Data (PlaceHolder.PostRn name name), Data.Data.Data (PlaceHolder.PostTc name name)) => Data.Data.Data (HsTypes.AmbiguousFieldOcc name)
- HsTypes: instance (Data.Data.Data name, Data.Data.Data thing, Data.Data.Data (PlaceHolder.PostRn name [Name.Name])) => Data.Data.Data (HsTypes.HsWildCardBndrs name thing)
- HsTypes: instance (Data.Data.Data name, Data.Data.Data thing, Data.Data.Data (PlaceHolder.PostRn name [Name.Name]), Data.Data.Data (PlaceHolder.PostRn name GHC.Types.Bool)) => Data.Data.Data (HsTypes.HsImplicitBndrs name thing)
- HsTypes: instance (Data.Data.Data rec, Data.Data.Data arg) => Data.Data.Data (HsTypes.HsConDetails arg rec)
- HsTypes: instance GHC.Classes.Eq (PlaceHolder.PostRn name name) => GHC.Classes.Eq (HsTypes.FieldOcc name)
- HsTypes: instance GHC.Classes.Ord (PlaceHolder.PostRn name name) => GHC.Classes.Ord (HsTypes.FieldOcc name)
- HsTypes: instance Outputable.Outputable (HsTypes.AmbiguousFieldOcc name)
- HsTypes: instance Outputable.Outputable (HsTypes.FieldOcc name)
- HsTypes: instance Outputable.Outputable (HsTypes.HsWildCardInfo name)
- HsTypes: instance Outputable.Outputable thing => Outputable.Outputable (HsTypes.HsImplicitBndrs name thing)
- HsTypes: instance Outputable.Outputable thing => Outputable.Outputable (HsTypes.HsWildCardBndrs name thing)
- HsTypes: instance Outputable.OutputableBndr (HsTypes.AmbiguousFieldOcc name)
- HsTypes: instance PlaceHolder.DataId name => Data.Data.Data (HsTypes.ConDeclField name)
- HsTypes: instance PlaceHolder.DataId name => Data.Data.Data (HsTypes.HsAppType name)
- HsTypes: instance PlaceHolder.DataId name => Data.Data.Data (HsTypes.HsTyVarBndr name)
- HsTypes: instance PlaceHolder.DataId name => Data.Data.Data (HsTypes.HsType name)
- HsTypes: instance PlaceHolder.DataId name => Data.Data.Data (HsTypes.HsWildCardInfo name)
- HsTypes: instance PlaceHolder.DataId name => Data.Data.Data (HsTypes.LHsQTyVars name)
- HsTypes: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsTypes.ConDeclField name)
- HsTypes: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsTypes.HsAppType name)
- HsTypes: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsTypes.HsTyVarBndr name)
- HsTypes: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsTypes.HsType name)
- HsTypes: instance PlaceHolder.OutputableBndrId name => Outputable.Outputable (HsTypes.LHsQTyVars name)
- HsTypes: pprParendHsType :: (OutputableBndrId name) => HsType name -> SDoc
- HsUtils: isBangedBind :: HsBind Id -> Bool
- HscTypes: hptObjs :: HomePackageTable -> [FilePath]
- HscTypes: type ModuleGraph = [ModSummary]
- IfaceType: IfaceHoleProv :: Unique -> IfaceUnivCoProv
- IfaceType: data IfRnEnv2
- IfaceType: emptyIfRnEnv2 :: IfRnEnv2
- IfaceType: eqIfaceTcArgs :: IfRnEnv2 -> IfaceTcArgs -> IfaceTcArgs -> Bool
- IfaceType: eqIfaceTvBndr :: IfaceTvBndr -> IfaceTvBndr -> Bool
- IfaceType: eqIfaceTvBndrs :: IfRnEnv2 -> [IfaceTvBndr] -> [IfaceTvBndr] -> Maybe IfRnEnv2
- IfaceType: eqIfaceType :: IfRnEnv2 -> IfaceType -> IfaceType -> Bool
- IfaceType: eqIfaceTypes :: IfRnEnv2 -> [IfaceType] -> [IfaceType] -> Bool
- IfaceType: substIfaceType :: IfaceTySubst -> IfaceType -> IfaceType
- Inst: tcInstBinderX :: Maybe (VarEnv Kind) -> TCvSubst -> TyBinder -> TcM (TCvSubst, TcType)
- Inst: tcInstBindersX :: TCvSubst -> Maybe (VarEnv Kind) -> [TyBinder] -> TcM (TCvSubst, [TcType])
- Kind: okArrowArgKind :: Kind -> Bool
- Kind: okArrowResultKind :: Kind -> Bool
- Kind: typeKind :: Type -> Kind
- ListSetOps: runs :: (a -> a -> Bool) -> [a] -> [[a]]
- LlvmCodeGen.CodeGen: instance Data.Semigroup.Semigroup LlvmCodeGen.CodeGen.LlvmAccum
- LlvmCodeGen.Ppr: pprLlvmHeader :: SDoc
- Module: [moduleName] :: Module -> !ModuleName
- Module: [moduleUnitId] :: Module -> !UnitId
- OccName: tidyOccNames :: TidyOccEnv -> [OccName] -> (TidyOccEnv, [OccName])
- OrdList: instance Data.Semigroup.Semigroup (OrdList.OrdList a)
- Outputable: pprPrefixOcc, pprInfixOcc :: OutputableBndr a => a -> SDoc
- Outputable: sdocWithPprDebug :: (Bool -> SDoc) -> SDoc
- Packages: instance Data.Semigroup.Semigroup Packages.ModuleOrigin
- Pair: instance GHC.Base.Monoid a => GHC.Base.Monoid (Pair.Pair a)
- PlaceHolder: type DataId id = (DataIdPost id, DataIdPost (NameOrRdrName id))
- PlaceHolder: type DataIdPost id = (Data id, Data (PostRn id NameSet), Data (PostRn id Fixity), Data (PostRn id Bool), Data (PostRn id Name), Data (PostRn id (Located Name)), Data (PostRn id [Name]), Data (PostRn id id), Data (PostTc id Type), Data (PostTc id Coercion), Data (PostTc id id), Data (PostTc id [Type]), Data (PostTc id ConLike), Data (PostTc id [ConLike]), Data (PostTc id HsWrapper), Data (PostTc id [FieldLabel]))
- PlaceHolder: type OutputableBndrId id = (OutputableBndr id, OutputableBndr (NameOrRdrName id))
- Platform: OSAndroid :: OS
- Platform: OSiOS :: OS
- Platform: platformBinariesAreStaticLibs :: Platform -> Bool
- PprCmm: instance Outputable.Outputable (Compiler.Hoopl.Block.Block CmmNode.CmmNode Compiler.Hoopl.Block.C Compiler.Hoopl.Block.C)
- PprCmm: instance Outputable.Outputable (Compiler.Hoopl.Block.Block CmmNode.CmmNode Compiler.Hoopl.Block.C Compiler.Hoopl.Block.O)
- PprCmm: instance Outputable.Outputable (Compiler.Hoopl.Block.Block CmmNode.CmmNode Compiler.Hoopl.Block.O Compiler.Hoopl.Block.C)
- PprCmm: instance Outputable.Outputable (Compiler.Hoopl.Block.Block CmmNode.CmmNode Compiler.Hoopl.Block.O Compiler.Hoopl.Block.O)
- PprCmm: instance Outputable.Outputable (Compiler.Hoopl.Graph.Graph CmmNode.CmmNode e x)
- PrelNames: dATA_MONOID :: Module
- PrelNames: dATA_SEMIGROUP :: Module
- PrelNames: ne_RDR :: RdrName
- PrelNames: showList_RDR :: RdrName
- PrelNames: showList___RDR :: RdrName
- RnEnv: ClassDeclCtx :: (Located RdrName) -> HsDocContext
- RnEnv: ClassInstanceCtx :: HsDocContext
- RnEnv: ConDeclCtx :: [Located Name] -> HsDocContext
- RnEnv: DefaultDeclCtx :: HsDocContext
- RnEnv: DerivDeclCtx :: HsDocContext
- RnEnv: ExprWithTySigCtx :: HsDocContext
- RnEnv: FamPatCtx :: (Located RdrName) -> HsDocContext
- RnEnv: ForeignDeclCtx :: (Located RdrName) -> HsDocContext
- RnEnv: GHCiCtx :: HsDocContext
- RnEnv: GenericCtx :: SDoc -> HsDocContext
- RnEnv: HsTypeCtx :: HsDocContext
- RnEnv: PatCtx :: HsDocContext
- RnEnv: RuleCtx :: FastString -> HsDocContext
- RnEnv: SpecInstSigCtx :: HsDocContext
- RnEnv: SpliceTypeCtx :: (LHsType RdrName) -> HsDocContext
- RnEnv: TyDataCtx :: (Located RdrName) -> HsDocContext
- RnEnv: TyFamilyCtx :: (Located RdrName) -> HsDocContext
- RnEnv: TySynCtx :: (Located RdrName) -> HsDocContext
- RnEnv: TypBrCtx :: HsDocContext
- RnEnv: TypeSigCtx :: SDoc -> HsDocContext
- RnEnv: VectDeclCtx :: (Located RdrName) -> HsDocContext
- RnEnv: addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
- RnEnv: addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a
- RnEnv: addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
- RnEnv: bindLocalNames :: [Name] -> RnM a -> RnM a
- RnEnv: bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
- RnEnv: bindLocatedLocalsFV :: [Located RdrName] -> ([Name] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
- RnEnv: bindLocatedLocalsRn :: [Located RdrName] -> ([Name] -> RnM a) -> RnM a
- RnEnv: checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
- RnEnv: checkDupNames :: [Name] -> RnM ()
- RnEnv: checkDupRdrNames :: [Located RdrName] -> RnM ()
- RnEnv: checkShadowedRdrNames :: [Located RdrName] -> RnM ()
- RnEnv: checkTupSize :: Int -> RnM ()
- RnEnv: data HsDocContext
- RnEnv: dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()
- RnEnv: emptyRoleAnnotEnv :: RoleAnnotEnv
- RnEnv: extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
- RnEnv: getLookupOccRn :: RnM (Name -> Maybe Name)
- RnEnv: getRoleAnnots :: [Name] -> RoleAnnotEnv -> ([LRoleAnnotDecl Name], RoleAnnotEnv)
- RnEnv: inHsDocContext :: HsDocContext -> SDoc
- RnEnv: isUnboundName :: Name -> Bool
- RnEnv: kindSigErr :: Outputable a => a -> SDoc
- RnEnv: lookupFieldFixityRn :: AmbiguousFieldOcc Name -> RnM Fixity
- RnEnv: lookupFixityRn :: Name -> RnM Fixity
- RnEnv: lookupFixityRn_help :: Name -> RnM (Bool, Fixity)
- RnEnv: lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl Name)
- RnEnv: lookupTyFixityRn :: Located Name -> RnM Fixity
- RnEnv: mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
- RnEnv: mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c) -> [a] -> ([b] -> RnM c) -> RnM c
- RnEnv: mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
- RnEnv: mkFieldEnv :: GlobalRdrEnv -> NameEnv (FieldLabelString, Name)
- RnEnv: mkRoleAnnotEnv :: [LRoleAnnotDecl Name] -> RoleAnnotEnv
- RnEnv: mkUnboundName :: OccName -> Name
- RnEnv: mkUnboundNameRdr :: RdrName -> Name
- RnEnv: newLocalBndrRn :: Located RdrName -> RnM Name
- RnEnv: newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
- RnEnv: perhapsForallMsg :: SDoc
- RnEnv: pprHsDocContext :: HsDocContext -> SDoc
- RnEnv: reportUnboundName :: RdrName -> RnM Name
- RnEnv: type MiniFixityEnv = FastStringEnv (Located Fixity)
- RnEnv: type RoleAnnotEnv = NameEnv (LRoleAnnotDecl Name)
- RnEnv: unknownNameSuggestions :: DynFlags -> GlobalRdrEnv -> LocalRdrEnv -> ImportAvails -> RdrName -> SDoc
- RnEnv: unknownSubordinateErr :: SDoc -> RdrName -> SDoc
- RnEnv: warnUnusedLocalBinds :: [Name] -> FreeVars -> RnM ()
- RnEnv: warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
- RnEnv: warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
- RnEnv: warnUnusedTypePatterns :: [Name] -> FreeVars -> RnM ()
- RnEnv: withHsDocContext :: HsDocContext -> SDoc -> SDoc
- SCCfinal: instance GHC.Base.Applicative SCCfinal.MassageM
- SCCfinal: instance GHC.Base.Functor SCCfinal.MassageM
- SCCfinal: instance GHC.Base.Monad SCCfinal.MassageM
- SCCfinal: stgMassageForProfiling :: DynFlags -> Module -> UniqSupply -> [StgTopBinding] -> (CollectedCCs, [StgTopBinding])
- SimplEnv: [seFloats] :: SimplEnv -> Floats
- SimplEnv: [seJoinFloats] :: SimplEnv -> JoinFloats
- SimplEnv: addNonRec :: SimplEnv -> OutId -> OutExpr -> SimplEnv
- SimplEnv: addRecFloats :: SimplEnv -> SimplEnv -> SimplEnv
- SimplEnv: data Floats
- SimplEnv: getFloatBinds :: SimplEnv -> [CoreBind]
- SimplEnv: getJoinFloatBinds :: SimplEnv -> [CoreBind]
- SimplEnv: instance Outputable.Outputable SimplEnv.Floats
- SimplEnv: isEmptyFloats :: SimplEnv -> Bool
- SimplEnv: isEmptyJoinFloats :: SimplEnv -> Bool
- SimplEnv: isJoinIdInEnv_maybe :: SimplEnv -> InId -> Maybe JoinArity
- SimplEnv: mapFloats :: SimplEnv -> ((Id, CoreExpr) -> (Id, CoreExpr)) -> SimplEnv
- SimplEnv: restoreJoinFloats :: SimplEnv -> SimplEnv -> SimplEnv
- SimplEnv: setFloats :: SimplEnv -> SimplEnv -> SimplEnv
- SimplEnv: setInScopeAndZapFloats :: SimplEnv -> SimplEnv -> SimplEnv
- SimplEnv: type StaticEnv = SimplEnv
- SimplEnv: zapFloats :: SimplEnv -> SimplEnv
- SimplEnv: zapJoinFloats :: SimplEnv -> SimplEnv
- SrcLoc: instance (Data.Data.Data e, Data.Data.Data l) => Data.Data.Data (SrcLoc.GenLocated l e)
- SrcLoc: instance (GHC.Classes.Eq e, GHC.Classes.Eq l) => GHC.Classes.Eq (SrcLoc.GenLocated l e)
- SrcLoc: instance (GHC.Classes.Ord e, GHC.Classes.Ord l) => GHC.Classes.Ord (SrcLoc.GenLocated l e)
- StgCmmClosure: dataConTagZ :: DataCon -> ConTagZ
- StgCmmClosure: type ConTagZ = Int
- StgCmmMonad: infixr 9 `thenFC`
- StgCmmMonad: listCs :: [FCode ()] -> FCode ()
- StgCmmMonad: newUniqSupply :: FCode UniqSupply
- StgCmmMonad: returnFC :: a -> FCode a
- StgCmmMonad: thenC :: FCode () -> FCode a -> FCode a
- StgCmmMonad: thenFC :: FCode a -> (a -> FCode c) -> FCode c
- SysTools: addFilesToClean :: DynFlags -> [FilePath] -> IO ()
- SysTools: askLd :: DynFlags -> [Option] -> IO String
- SysTools: cleanTempDirs :: DynFlags -> IO ()
- SysTools: cleanTempFiles :: DynFlags -> IO ()
- SysTools: cleanTempFilesExcept :: DynFlags -> [FilePath] -> IO ()
- SysTools: figureLlvmVersion :: DynFlags -> IO (Maybe (Int, Int))
- SysTools: getCompilerInfo :: DynFlags -> IO CompilerInfo
- SysTools: getLinkerInfo :: DynFlags -> IO LinkerInfo
- SysTools: newTempLibName :: DynFlags -> Suffix -> IO (FilePath, FilePath, String)
- SysTools: newTempName :: DynFlags -> Suffix -> IO FilePath
- SysTools: runAs :: DynFlags -> [Option] -> IO ()
- SysTools: runCc :: DynFlags -> [Option] -> IO ()
- SysTools: runClang :: DynFlags -> [Option] -> IO ()
- SysTools: runCpp :: DynFlags -> [Option] -> IO ()
- SysTools: runLibtool :: DynFlags -> [Option] -> IO ()
- SysTools: runLink :: DynFlags -> [Option] -> IO ()
- SysTools: runLlvmLlc :: DynFlags -> [Option] -> IO ()
- SysTools: runLlvmOpt :: DynFlags -> [Option] -> IO ()
- SysTools: runMkDLL :: DynFlags -> [Option] -> IO ()
- SysTools: runPp :: DynFlags -> [Option] -> IO ()
- SysTools: runSplit :: DynFlags -> [Option] -> IO ()
- SysTools: runUnlit :: DynFlags -> [Option] -> IO ()
- SysTools: runWindres :: DynFlags -> [Option] -> IO ()
- SysTools: setTmpDir :: FilePath -> DynFlags -> DynFlags
- SysTools: touch :: DynFlags -> String -> String -> IO ()
- THNames: dataFamIdKey :: Unique
- THNames: dataFamName :: Name
- THNames: kindTyConKey :: Unique
- THNames: kindTyConName :: Name
- THNames: tyVarBndrTyConKey :: Unique
- THNames: tyVarBndrTyConName :: Name
- THNames: typeFamIdKey :: Unique
- THNames: typeFamName :: Name
- TcEnv: instance PlaceHolder.OutputableBndrId a => Outputable.Outputable (TcEnv.InstInfo a)
- TcEnv: tcExtendIdBndrs :: [TcIdBinder] -> TcM a -> TcM a
- TcErrors: instance Data.Semigroup.Semigroup TcErrors.Report
- TcFlatten: unflatten :: Cts -> Cts -> TcS Cts
- TcHsSyn: nlHsIntLit :: Integer -> LHsExpr id
- TcHsType: kcHsTyVarBndrs :: Name -> Bool -> Bool -> Bool -> Bool -> LHsQTyVars Name -> TcM (Kind, r) -> TcM (TcTyCon, r)
- TcHsType: tcInferArgs :: Outputable fun => fun -> [TyConBinder] -> Maybe (VarEnv Kind) -> [LHsType Name] -> TcM (TCvSubst, [TyBinder], [TcType], [LHsType Name], Int)
- TcInteract: solveCallStack :: CtEvidence -> EvCallStack -> TcS ()
- TcMType: mkTypeErrorThing :: TcType -> ErrorThing
- TcMType: mkTypeErrorThingArgs :: TcType -> Int -> ErrorThing
- TcMType: quantifyZonkedTyVars :: TcTyCoVarSet -> CandidatesQTvs -> TcM [TcTyVar]
- TcRnExports: instance GHC.Base.Monoid TcRnExports.ChildLookupResult
- TcRnExports: instance GHC.Base.Monoid TcRnExports.DisambigInfo
- TcRnExports: instance Outputable.Outputable TcRnExports.ChildLookupResult
- TcRnMonad: tcInitOpenTidyEnv :: [TyCoVar] -> TcM TidyEnv
- TcRnMonad: tcInitTidyEnv :: TcM TidyEnv
- TcRnTypes: CIrredEvCan :: CtEvidence -> Ct
- TcRnTypes: ErrorThing :: a -> (Maybe Arity) -> (TidyEnv -> a -> TcM (TidyEnv, a)) -> ErrorThing
- TcRnTypes: [ic_needed] :: Implication -> VarSet
- TcRnTypes: [ics_need] :: ImplicStatus -> VarSet
- TcRnTypes: [tcg_pending_fam_checks] :: TcGblEnv -> NameEnv [([FamInst], FamInstEnv)]
- TcRnTypes: [tcl_tidy] :: TcLclEnv -> TidyEnv
- TcRnTypes: [wc_insol] :: WantedConstraints -> Cts
- TcRnTypes: data ErrorThing
- TcRnTypes: data TcIdBinder
- TcRnTypes: dropDerivedInsols :: Cts -> Cts
- TcRnTypes: eqCanDischarge :: CtEvidence -> CtEvidence -> Bool
- TcRnTypes: errorThingNumArgs_maybe :: ErrorThing -> Maybe Arity
- TcRnTypes: getInsolubles :: WantedConstraints -> Cts
- TcRnTypes: instance OccName.HasOccName TcRnTypes.TcIdBinder
- TcRnTypes: instance Outputable.Outputable TcRnTypes.ErrorThing
- TcRnTypes: instance Outputable.Outputable TcRnTypes.TcIdBinder
- TcRnTypes: isCIrredEvCan :: Ct -> Bool
- TcRnTypes: isDroppableDerivedLoc :: CtLoc -> Bool
- TcRnTypes: mkErrorThing :: Outputable a => a -> ErrorThing
- TcRnTypes: trulyInsoluble :: Ct -> Bool
- TcRnTypes: type TcIdBinderStack = [TcIdBinder]
- TcSMonad: [inert_insols] :: InertCans -> Cts
- TcSMonad: [wl_deriv] :: WorkList -> [CtEvidence]
- TcSMonad: emitInsoluble :: Ct -> TcS ()
- TcSMonad: emitNewDerived :: CtLoc -> TcPredType -> TcS ()
- TcSMonad: emptyInert :: InertSet
- TcSMonad: extendWorkListDerived :: CtLoc -> CtEvidence -> WorkList -> WorkList
- TcSMonad: getTcEvBindsAndTCVs :: EvBindsVar -> TcS (EvBindMap, TyCoVarSet)
- TcTyClsDecls: famTyConShape :: TyCon -> FamTyConShape
- TcType: FlatSkol :: TcType -> TcTyVarDetails
- TcType: isRigidEqPred :: TcLevel -> PredTree -> Bool
- TcType: isTyVarExposed :: TcTyVar -> TcType -> Bool
- TcUnify: noThing :: Maybe (HsExpr Name)
- TcUnify: wrapFunResCoercion :: [TcType] -> HsWrapper -> TcM HsWrapper
- TyCon: familyTyConInjectivityInfo :: TyCon -> Injectivity
- TyCon: primRepSizeW :: DynFlags -> PrimRep -> Int
- Type: extendTvSubstBinder :: TCvSubst -> TyBinder -> Type -> TCvSubst
- Type: filterOutInvisibleTyVars :: TyCon -> [TyVar] -> [TyVar]
- Type: isClosedAlgType :: Type -> Bool
- Type: pprArrowChain :: TyPrec -> [SDoc] -> SDoc
- Type: pprPrefixApp :: TyPrec -> SDoc -> [SDoc] -> SDoc
- Type: substTyWithInScope :: InScopeSet -> [TyVar] -> [Type] -> Type -> Type
- UniqFM: instance Data.Semigroup.Semigroup (UniqFM.UniqFM a)
- UniqSet: instance Data.Semigroup.Semigroup (UniqSet.UniqSet a)
- Util: data CallStack :: *
- Util: prettyCurrentCallStack :: HasCallStack => String
- Var: instance (Data.Data.Data argf, Data.Data.Data tyvar) => Data.Data.Data (Var.TyVarBndr tyvar argf)
- Vectorise.Utils.Base: dataConTagZ :: DataCon -> Int
+ Ar: Archive :: [ArchiveEntry] -> Archive
+ Ar: ArchiveEntry :: String -> Int -> Int -> Int -> Int -> Int -> ByteString -> ArchiveEntry
+ Ar: [filedata] :: ArchiveEntry -> ByteString
+ Ar: [filegrp] :: ArchiveEntry -> Int
+ Ar: [filemode] :: ArchiveEntry -> Int
+ Ar: [filename] :: ArchiveEntry -> String
+ Ar: [fileown] :: ArchiveEntry -> Int
+ Ar: [filesize] :: ArchiveEntry -> Int
+ Ar: [filetime] :: ArchiveEntry -> Int
+ Ar: afilter :: (ArchiveEntry -> Bool) -> Archive -> Archive
+ Ar: data ArchiveEntry
+ Ar: instance GHC.Base.Monoid Ar.Archive
+ Ar: instance GHC.Base.Semigroup Ar.Archive
+ Ar: instance GHC.Classes.Eq Ar.Archive
+ Ar: instance GHC.Classes.Eq Ar.ArchiveEntry
+ Ar: instance GHC.Show.Show Ar.Archive
+ Ar: instance GHC.Show.Show Ar.ArchiveEntry
+ Ar: isBSDSymdef :: ArchiveEntry -> Bool
+ Ar: isGNUSymdef :: ArchiveEntry -> Bool
+ Ar: loadAr :: FilePath -> IO Archive
+ Ar: loadObj :: FilePath -> IO ArchiveEntry
+ Ar: newtype Archive
+ Ar: parseAr :: ByteString -> Archive
+ Ar: writeBSDAr :: FilePath -> Archive -> IO ()
+ Ar: writeGNUAr :: FilePath -> Archive -> IO ()
+ AsmUtils: sectionType :: String -> SDoc
+ Avail: instance Data.Data.Data Avail.AvailInfo
+ Bag: instance GHC.Base.Functor Bag.Bag
+ BasicTypes: IL :: SourceText -> Bool -> Integer -> IntegralLit
+ BasicTypes: NoUserInline :: InlineSpec
+ BasicTypes: [fl_neg] :: FractionalLit -> Bool
+ BasicTypes: [il_neg] :: IntegralLit -> Bool
+ BasicTypes: [il_text] :: IntegralLit -> SourceText
+ BasicTypes: [il_value] :: IntegralLit -> Integer
+ BasicTypes: data IntegralLit
+ BasicTypes: instance Data.Data.Data BasicTypes.IntegralLit
+ BasicTypes: instance GHC.Classes.Eq BasicTypes.IntegralLit
+ BasicTypes: instance GHC.Classes.Ord BasicTypes.IntegralLit
+ BasicTypes: instance GHC.Show.Show BasicTypes.IntegralLit
+ BasicTypes: instance Outputable.Outputable BasicTypes.IntegralLit
+ BasicTypes: mkFractionalLit :: Real a => a -> FractionalLit
+ BasicTypes: mkIntegralLit :: Integral a => a -> IntegralLit
+ BasicTypes: negateIntegralLit :: IntegralLit -> IntegralLit
+ BasicTypes: noUserInlineSpec :: InlineSpec -> Bool
+ ByteCodeGen: instance GHC.Classes.Eq ByteCodeGen.ByteOff
+ ByteCodeGen: instance GHC.Classes.Eq ByteCodeGen.WordOff
+ ByteCodeGen: instance GHC.Classes.Ord ByteCodeGen.ByteOff
+ ByteCodeGen: instance GHC.Classes.Ord ByteCodeGen.WordOff
+ ByteCodeGen: instance GHC.Enum.Enum ByteCodeGen.ByteOff
+ ByteCodeGen: instance GHC.Enum.Enum ByteCodeGen.WordOff
+ ByteCodeGen: instance GHC.Num.Num ByteCodeGen.ByteOff
+ ByteCodeGen: instance GHC.Num.Num ByteCodeGen.WordOff
+ ByteCodeGen: instance GHC.Real.Integral ByteCodeGen.ByteOff
+ ByteCodeGen: instance GHC.Real.Integral ByteCodeGen.WordOff
+ ByteCodeGen: instance GHC.Real.Real ByteCodeGen.ByteOff
+ ByteCodeGen: instance GHC.Real.Real ByteCodeGen.WordOff
+ ByteCodeInstr: PUSH16 :: !Word16 -> BCInstr
+ ByteCodeInstr: PUSH16_W :: !Word16 -> BCInstr
+ ByteCodeInstr: PUSH32 :: !Word16 -> BCInstr
+ ByteCodeInstr: PUSH32_W :: !Word16 -> BCInstr
+ ByteCodeInstr: PUSH8 :: !Word16 -> BCInstr
+ ByteCodeInstr: PUSH8_W :: !Word16 -> BCInstr
+ ByteCodeInstr: PUSH_PAD16 :: BCInstr
+ ByteCodeInstr: PUSH_PAD32 :: BCInstr
+ ByteCodeInstr: PUSH_PAD8 :: BCInstr
+ ByteCodeInstr: PUSH_UBX16 :: Literal -> BCInstr
+ ByteCodeInstr: PUSH_UBX32 :: Literal -> BCInstr
+ ByteCodeInstr: PUSH_UBX8 :: Literal -> BCInstr
+ CLabel: instance GHC.Show.Show CLabel.IdLabelInfo
+ CLabel: isSomeRODataLabel :: CLabel -> Bool
+ CLabel: isStaticClosureLabel :: CLabel -> Bool
+ CLabel: maybeLocalBlockLabel :: CLabel -> Maybe BlockId
+ CLabel: mkBadAlignmentLabel :: CLabel
+ CLabel: mkBlockInfoTableLabel :: Name -> CafInfo -> CLabel
+ CLabel: mkLocalBlockLabel :: Unique -> CLabel
+ CPrim: pdepLabel :: Width -> String
+ CPrim: pextLabel :: Width -> String
+ Check: instance GHC.Base.Semigroup Check.Covered
+ Check: instance GHC.Base.Semigroup Check.Diverged
+ Check: instance GHC.Base.Semigroup Check.PartialResult
+ Check: instance GHC.Base.Semigroup Check.Provenance
+ Check: pmIsClosedType :: Type -> Bool
+ Check: pmTopNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe (Type, [DataCon], Type)
+ CmdLineParser: Err :: Located String -> Err
+ CmdLineParser: NoReason :: WarnReason
+ CmdLineParser: ReasonDeprecatedFlag :: WarnReason
+ CmdLineParser: ReasonUnrecognisedFlag :: WarnReason
+ CmdLineParser: Warn :: WarnReason -> Located String -> Warn
+ CmdLineParser: [errMsg] :: Err -> Located String
+ CmdLineParser: [warnMsg] :: Warn -> Located String
+ CmdLineParser: [warnReason] :: Warn -> WarnReason
+ CmdLineParser: addFlagWarn :: Monad m => WarnReason -> String -> EwM m ()
+ CmdLineParser: data Warn
+ CmdLineParser: data WarnReason
+ CmdLineParser: instance GHC.Classes.Eq CmdLineParser.WarnReason
+ CmdLineParser: instance GHC.Show.Show CmdLineParser.WarnReason
+ CmdLineParser: instance Json.ToJson CmdLineParser.WarnReason
+ CmdLineParser: instance Outputable.Outputable CmdLineParser.WarnReason
+ CmdLineParser: newtype Err
+ Cmm: isSecConstant :: Section -> Bool
+ CmmMachOp: MO_AlignmentCheck :: Int -> Width -> MachOp
+ CmmMachOp: MO_Memcmp :: Int -> CallishMachOp
+ CmmMachOp: MO_Pdep :: Width -> CallishMachOp
+ CmmMachOp: MO_Pext :: Width -> CallishMachOp
+ CmmNode: instance Hoopl.Graph.NonLocal CmmNode.CmmNode
+ Constants: fLOAT_SIZE :: Int
+ CoreArity: instance Outputable.Outputable CoreArity.ArityType
+ CoreFVs: type FVAnn = DVarSet
+ CoreMonad: CoreDoExitify :: CoreToDo
+ CoreMonad: [sm_dflags] :: SimplMode -> DynFlags
+ CoreMonad: data SimplMode
+ CoreMonad: instance Outputable.Outputable CoreMonad.SimplMode
+ CoreSyn: deAnnBind :: AnnBind b annot -> Bind b
+ CoreSyn: instance GHC.Classes.Ord CoreSyn.AltCon
+ CoreSyn: mkLetNonRec :: b -> Expr b -> Expr b -> Expr b
+ CoreSyn: mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b
+ CoreUtils: altsAreExhaustive :: [Alt b] -> Bool
+ CoreUtils: exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool
+ CostCentre: collectCC :: CostCentre -> CostCentreStack -> CollectedCCs -> CollectedCCs
+ CostCentre: emptyCollectedCCs :: CollectedCCs
+ DataCon: dataConTagZ :: DataCon -> ConTagZ
+ DataCon: dataConUnivAndExTyVars :: DataCon -> [TyVar]
+ DataCon: dataConUserTyVarBinders :: DataCon -> [TyVarBinder]
+ DataCon: dataConUserTyVars :: DataCon -> [TyVar]
+ DataCon: dataConUserTyVarsArePermuted :: DataCon -> Bool
+ Demand: instance (GHC.Classes.Eq s, GHC.Classes.Eq u) => GHC.Classes.Eq (Demand.JointDmd s u)
+ Demand: instance (GHC.Show.Show s, GHC.Show.Show u) => GHC.Show.Show (Demand.JointDmd s u)
+ Digraph: DigraphNode :: payload -> key -> [key] -> Node key payload
+ Digraph: [node_dependencies] :: Node key payload -> [key]
+ Digraph: [node_key] :: Node key payload -> key
+ Digraph: [node_payload] :: Node key payload -> payload
+ Digraph: data Node key payload
+ Digraph: instance (Outputable.Outputable a, Outputable.Outputable b) => Outputable.Outputable (Digraph.Node a b)
+ DsMonad: pprRuntimeTrace :: String -> SDoc -> CoreExpr -> DsM CoreExpr
+ DynFlags: ErrReason :: !(Maybe WarningFlag) -> WarnReason
+ DynFlags: FilesToClean :: !(Set FilePath) -> !(Set FilePath) -> FilesToClean
+ DynFlags: LlvmLLD :: [Option] -> LinkerInfo
+ DynFlags: LlvmTarget :: String -> String -> [String] -> LlvmTarget
+ DynFlags: Opt_AlignmentSanitisation :: GeneralFlag
+ DynFlags: Opt_CatchBottoms :: GeneralFlag
+ DynFlags: Opt_D_dump_exitify :: DumpFlag
+ DynFlags: Opt_D_dump_timings :: DumpFlag
+ DynFlags: Opt_Exitification :: GeneralFlag
+ DynFlags: Opt_FastLlvm :: GeneralFlag
+ DynFlags: Opt_IgnoreHpcChanges :: GeneralFlag
+ DynFlags: Opt_IgnoreOptimChanges :: GeneralFlag
+ DynFlags: Opt_SuppressStgFreeVars :: GeneralFlag
+ DynFlags: Opt_WarnMissingExportList :: WarningFlag
+ DynFlags: Opt_WarnPartialFields :: WarningFlag
+ DynFlags: RtsOptsIgnore :: RtsOptsEnabled
+ DynFlags: RtsOptsIgnoreAll :: RtsOptsEnabled
+ DynFlags: [bmiVersion] :: DynFlags -> Maybe BmiVersion
+ DynFlags: [ftcCurrentModule] :: FilesToClean -> !(Set FilePath)
+ DynFlags: [ftcGhcSession] :: FilesToClean -> !(Set FilePath)
+ DynFlags: [ghcVersionFile] :: DynFlags -> Maybe FilePath
+ DynFlags: [lAttributes] :: LlvmTarget -> [String]
+ DynFlags: [lCPU] :: LlvmTarget -> String
+ DynFlags: [lDataLayout] :: LlvmTarget -> String
+ DynFlags: [llvmTargets] :: DynFlags -> LlvmTargets
+ DynFlags: [maxValidSubstitutions] :: DynFlags -> Maybe Int
+ DynFlags: [sOpt_lcc] :: Settings -> [String]
+ DynFlags: [sPgm_ar] :: Settings -> String
+ DynFlags: [sPgm_lcc] :: Settings -> (String, [Option])
+ DynFlags: [sPgm_ranlib] :: Settings -> String
+ DynFlags: addPluginModuleName :: String -> DynFlags -> DynFlags
+ DynFlags: data FilesToClean
+ DynFlags: data LlvmTarget
+ DynFlags: emptyFilesToClean :: FilesToClean
+ DynFlags: instance GHC.Classes.Eq DynFlags.BmiVersion
+ DynFlags: instance GHC.Classes.Ord DynFlags.BmiVersion
+ DynFlags: isBmi2Enabled :: DynFlags -> Bool
+ DynFlags: isBmiEnabled :: DynFlags -> Bool
+ DynFlags: opt_lcc :: DynFlags -> [String]
+ DynFlags: optimisationFlags :: EnumSet GeneralFlag
+ DynFlags: pgm_ar :: DynFlags -> String
+ DynFlags: pgm_lcc :: DynFlags -> (String, [Option])
+ DynFlags: pgm_ranlib :: DynFlags -> String
+ DynFlags: type LlvmTargets = [(String, LlvmTarget)]
+ EnumSet: data EnumSet a
+ EnumSet: delete :: Enum a => a -> EnumSet a -> EnumSet a
+ EnumSet: empty :: EnumSet a
+ EnumSet: fromList :: Enum a => [a] -> EnumSet a
+ EnumSet: insert :: Enum a => a -> EnumSet a -> EnumSet a
+ EnumSet: member :: Enum a => a -> EnumSet a -> Bool
+ EnumSet: toList :: Enum a => EnumSet a -> [a]
+ ErrUtils: errMsgReason :: ErrMsg -> WarnReason
+ ErrUtils: errMsgSeverity :: ErrMsg -> Severity
+ ErrUtils: orValid :: Validity -> Validity -> Validity
+ ErrUtils: traceCmd :: DynFlags -> String -> String -> IO a -> IO a
+ Exitify: exitifyProgram :: CoreProgram -> CoreProgram
+ FamInstEnv: normaliseTcArgs :: FamInstEnvs -> Role -> TyCon -> [Type] -> (Coercion, [Type])
+ FastString: instance GHC.Base.Semigroup FastString.FastString
+ FileCleanup: TFL_CurrentModule :: TempFileLifetime
+ FileCleanup: TFL_GhcSession :: TempFileLifetime
+ FileCleanup: addFilesToClean :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()
+ FileCleanup: changeTempFilesLifetime :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()
+ FileCleanup: cleanCurrentModuleTempFiles :: DynFlags -> IO ()
+ FileCleanup: cleanTempDirs :: DynFlags -> IO ()
+ FileCleanup: cleanTempFiles :: DynFlags -> IO ()
+ FileCleanup: data TempFileLifetime
+ FileCleanup: instance GHC.Show.Show FileCleanup.TempFileLifetime
+ FileCleanup: newTempLibName :: DynFlags -> TempFileLifetime -> Suffix -> IO (FilePath, FilePath, String)
+ FileCleanup: newTempName :: DynFlags -> TempFileLifetime -> Suffix -> IO FilePath
+ FileCleanup: withSystemTempDirectory :: String -> (FilePath -> IO a) -> IO a
+ FileCleanup: withTempDirectory :: FilePath -> String -> (FilePath -> IO a) -> IO a
+ FlagChecker: fingerprintHpcFlags :: DynFlags -> (BinHandle -> Name -> IO ()) -> IO Fingerprint
+ FlagChecker: fingerprintOptFlags :: DynFlags -> (BinHandle -> Name -> IO ()) -> IO Fingerprint
+ GHC: Opt_AlignmentSanitisation :: GeneralFlag
+ GHC: Opt_CatchBottoms :: GeneralFlag
+ GHC: Opt_Exitification :: GeneralFlag
+ GHC: Opt_FastLlvm :: GeneralFlag
+ GHC: Opt_IgnoreHpcChanges :: GeneralFlag
+ GHC: Opt_IgnoreOptimChanges :: GeneralFlag
+ GHC: Opt_SuppressStgFreeVars :: GeneralFlag
+ GHC: [bmiVersion] :: DynFlags -> Maybe BmiVersion
+ GHC: [ghcVersionFile] :: DynFlags -> Maybe FilePath
+ GHC: [llvmTargets] :: DynFlags -> LlvmTargets
+ GHC: [maxValidSubstitutions] :: DynFlags -> Maybe Int
+ GHC: [mi_hpc_hash] :: ModIface -> !Fingerprint
+ GHC: [mi_opt_hash] :: ModIface -> !Fingerprint
+ GHC: data ModuleGraph
+ GHC: emptyMG :: ModuleGraph
+ GHC: mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph
+ GHC: mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary
+ GHC: mgModSummaries :: ModuleGraph -> [ModSummary]
+ GHC: mkModuleGraph :: [ModSummary] -> ModuleGraph
+ GHC: needsTemplateHaskellOrQQ :: ModuleGraph -> Bool
+ GhcPlugins: ACoAxiom :: (CoAxiom Branched) -> TyThing
+ GhcPlugins: AConLike :: ConLike -> TyThing
+ GhcPlugins: ATyCon :: TyCon -> TyThing
+ GhcPlugins: ActiveAfter :: SourceText -> PhaseNum -> Activation
+ GhcPlugins: ActiveBefore :: SourceText -> PhaseNum -> Activation
+ GhcPlugins: AlwaysActive :: Activation
+ GhcPlugins: AlwaysTailCalled :: JoinArity -> TailCallInfo
+ GhcPlugins: AnId :: Id -> TyThing
+ GhcPlugins: AnyclassStrategy :: DerivStrategy
+ GhcPlugins: Boxed :: Boxity
+ GhcPlugins: BoxedTuple :: TupleSort
+ GhcPlugins: BuiltInSyntax :: BuiltInSyntax
+ GhcPlugins: CLeft :: LeftOrRight
+ GhcPlugins: CRight :: LeftOrRight
+ GhcPlugins: ClassPred :: Class -> [Type] -> PredTree
+ GhcPlugins: ConLike :: RuleMatchInfo
+ GhcPlugins: ConstraintTuple :: TupleSort
+ GhcPlugins: DeprecatedTxt :: (Located SourceText) -> [Located StringLiteral] -> WarningTxt
+ GhcPlugins: EP :: a -> a -> EP a
+ GhcPlugins: EqPred :: EqRel -> Type -> Type -> PredTree
+ GhcPlugins: ExplicitSplice :: SpliceExplicitFlag
+ GhcPlugins: FL :: SourceText -> Bool -> Rational -> FractionalLit
+ GhcPlugins: Failed :: SuccessFlag
+ GhcPlugins: Fixity :: SourceText -> Int -> FixityDirection -> Fixity
+ GhcPlugins: FromSource :: Origin
+ GhcPlugins: FunLike :: RuleMatchInfo
+ GhcPlugins: FunPrec :: TyPrec
+ GhcPlugins: Generated :: Origin
+ GhcPlugins: GenericDM :: ty -> DefMethSpec ty
+ GhcPlugins: IAmALoopBreaker :: !RulesOnly -> !TailCallInfo -> OccInfo
+ GhcPlugins: IAmDead :: OccInfo
+ GhcPlugins: IL :: SourceText -> Bool -> Integer -> IntegralLit
+ GhcPlugins: ImplicitSplice :: SpliceExplicitFlag
+ GhcPlugins: Incoherent :: SourceText -> OverlapMode
+ GhcPlugins: Inferred :: ArgFlag
+ GhcPlugins: Infix :: LexicalFixity
+ GhcPlugins: InfixL :: FixityDirection
+ GhcPlugins: InfixN :: FixityDirection
+ GhcPlugins: InfixR :: FixityDirection
+ GhcPlugins: InitialPhase :: CompilerPhase
+ GhcPlugins: Inlinable :: InlineSpec
+ GhcPlugins: Inline :: InlineSpec
+ GhcPlugins: InlinePragma :: SourceText -> InlineSpec -> Maybe Arity -> Activation -> RuleMatchInfo -> InlinePragma
+ GhcPlugins: IrredPred :: PredType -> PredTree
+ GhcPlugins: IsData :: FunctionOrData
+ GhcPlugins: IsFunction :: FunctionOrData
+ GhcPlugins: IsSwapped :: SwapFlag
+ GhcPlugins: LC :: TCvSubst -> LiftCoEnv -> LiftingContext
+ GhcPlugins: ManyOccs :: !TailCallInfo -> OccInfo
+ GhcPlugins: NS_Abort :: NormaliseStepResult ev
+ GhcPlugins: NS_Done :: NormaliseStepResult ev
+ GhcPlugins: NS_Step :: RecTcChecker -> Type -> ev -> NormaliseStepResult ev
+ GhcPlugins: NeverActive :: Activation
+ GhcPlugins: NewtypeStrategy :: DerivStrategy
+ GhcPlugins: NoInline :: InlineSpec
+ GhcPlugins: NoOneShotInfo :: OneShotInfo
+ GhcPlugins: NoOverlap :: SourceText -> OverlapMode
+ GhcPlugins: NoSourceText :: SourceText
+ GhcPlugins: NoTailCallInfo :: TailCallInfo
+ GhcPlugins: NoUserInline :: InlineSpec
+ GhcPlugins: NomEq :: EqRel
+ GhcPlugins: Nominal :: Role
+ GhcPlugins: NonRecursive :: RecFlag
+ GhcPlugins: NotSwapped :: SwapFlag
+ GhcPlugins: NotTopLevel :: TopLevelFlag
+ GhcPlugins: OneOcc :: !InsideLam -> !OneBranch -> !InterestingCxt -> !TailCallInfo -> OccInfo
+ GhcPlugins: OneShotLam :: OneShotInfo
+ GhcPlugins: OverlapFlag :: OverlapMode -> Bool -> OverlapFlag
+ GhcPlugins: Overlappable :: SourceText -> OverlapMode
+ GhcPlugins: Overlapping :: SourceText -> OverlapMode
+ GhcPlugins: Overlaps :: SourceText -> OverlapMode
+ GhcPlugins: Phantom :: Role
+ GhcPlugins: Phase :: PhaseNum -> CompilerPhase
+ GhcPlugins: Prefix :: LexicalFixity
+ GhcPlugins: Recursive :: RecFlag
+ GhcPlugins: ReprEq :: EqRel
+ GhcPlugins: Representational :: Role
+ GhcPlugins: Required :: ArgFlag
+ GhcPlugins: SourceText :: String -> SourceText
+ GhcPlugins: Specified :: ArgFlag
+ GhcPlugins: StockStrategy :: DerivStrategy
+ GhcPlugins: StringLiteral :: SourceText -> FastString -> StringLiteral
+ GhcPlugins: Subst :: InScopeSet -> IdSubstEnv -> TvSubstEnv -> CvSubstEnv -> Subst
+ GhcPlugins: Succeeded :: SuccessFlag
+ GhcPlugins: TCvSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> TCvSubst
+ GhcPlugins: TopLevel :: TopLevelFlag
+ GhcPlugins: TopPrec :: TyPrec
+ GhcPlugins: TyCoMapper :: Bool -> env -> TyVar -> m Type -> env -> CoVar -> m Coercion -> env -> CoercionHole -> m Coercion -> env -> TyVar -> ArgFlag -> m (env, TyVar) -> TyCoMapper env m
+ GhcPlugins: TyConPrec :: TyPrec
+ GhcPlugins: TyOpPrec :: TyPrec
+ GhcPlugins: Unboxed :: Boxity
+ GhcPlugins: UnboxedTuple :: TupleSort
+ GhcPlugins: UserSyntax :: BuiltInSyntax
+ GhcPlugins: VanillaDM :: DefMethSpec ty
+ GhcPlugins: WarningTxt :: (Located SourceText) -> [Located StringLiteral] -> WarningTxt
+ GhcPlugins: [fl_neg] :: FractionalLit -> Bool
+ GhcPlugins: [fl_text] :: FractionalLit -> SourceText
+ GhcPlugins: [fl_value] :: FractionalLit -> Rational
+ GhcPlugins: [fromEP] :: EP a -> a
+ GhcPlugins: [il_neg] :: IntegralLit -> Bool
+ GhcPlugins: [il_text] :: IntegralLit -> SourceText
+ GhcPlugins: [il_value] :: IntegralLit -> Integer
+ GhcPlugins: [inl_act] :: InlinePragma -> Activation
+ GhcPlugins: [inl_inline] :: InlinePragma -> InlineSpec
+ GhcPlugins: [inl_rule] :: InlinePragma -> RuleMatchInfo
+ GhcPlugins: [inl_sat] :: InlinePragma -> Maybe Arity
+ GhcPlugins: [inl_src] :: InlinePragma -> SourceText
+ GhcPlugins: [isSafeOverlap] :: OverlapFlag -> Bool
+ GhcPlugins: [occ_in_lam] :: OccInfo -> !InsideLam
+ GhcPlugins: [occ_int_cxt] :: OccInfo -> !InterestingCxt
+ GhcPlugins: [occ_one_br] :: OccInfo -> !OneBranch
+ GhcPlugins: [occ_rules_only] :: OccInfo -> !RulesOnly
+ GhcPlugins: [occ_tail] :: OccInfo -> !TailCallInfo
+ GhcPlugins: [overlapMode] :: OverlapFlag -> OverlapMode
+ GhcPlugins: [sl_fs] :: StringLiteral -> FastString
+ GhcPlugins: [sl_st] :: StringLiteral -> SourceText
+ GhcPlugins: [tcm_covar] :: TyCoMapper env m -> env -> CoVar -> m Coercion
+ GhcPlugins: [tcm_hole] :: TyCoMapper env m -> env -> CoercionHole -> m Coercion
+ GhcPlugins: [tcm_smart] :: TyCoMapper env m -> Bool
+ GhcPlugins: [tcm_tybinder] :: TyCoMapper env m -> env -> TyVar -> ArgFlag -> m (env, TyVar)
+ GhcPlugins: [tcm_tyvar] :: TyCoMapper env m -> env -> TyVar -> m Type
+ GhcPlugins: [toEP] :: EP a -> a
+ GhcPlugins: addInScopeSet :: Subst -> VarSet -> Subst
+ GhcPlugins: alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt
+ GhcPlugins: alwaysInlinePragma :: InlinePragma
+ GhcPlugins: applyTysX :: [TyVar] -> Type -> [Type] -> Type
+ GhcPlugins: asJoinId :: Id -> JoinArity -> JoinId
+ GhcPlugins: asJoinId_maybe :: Id -> Maybe JoinArity -> Id
+ GhcPlugins: avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv
+ GhcPlugins: bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo
+ GhcPlugins: binderArgFlag :: TyVarBndr tv argf -> argf
+ GhcPlugins: binderKind :: TyVarBndr TyVar argf -> Kind
+ GhcPlugins: binderRelevantType_maybe :: TyBinder -> Maybe Type
+ GhcPlugins: binderVar :: TyVarBndr tv argf -> tv
+ GhcPlugins: binderVars :: [TyVarBndr tv argf] -> [tv]
+ GhcPlugins: boolToRecFlag :: Bool -> RecFlag
+ GhcPlugins: boxityTupleSort :: Boxity -> TupleSort
+ GhcPlugins: bumpVersion :: Version -> Version
+ GhcPlugins: caseBinder :: TyBinder -> (TyVarBinder -> a) -> (Type -> a) -> a
+ GhcPlugins: castCoercionKind :: Coercion -> Coercion -> Coercion -> Coercion
+ GhcPlugins: class HasOccName name
+ GhcPlugins: class NamedThing a
+ GhcPlugins: class Uniquable a
+ GhcPlugins: classifyPredType :: PredType -> PredTree
+ GhcPlugins: clearOneShotLambda :: Id -> Id
+ GhcPlugins: cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)
+ GhcPlugins: cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])
+ GhcPlugins: cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)
+ GhcPlugins: cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
+ GhcPlugins: cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
+ GhcPlugins: cloneTyVarBndr :: TCvSubst -> TyVar -> Unique -> (TCvSubst, TyVar)
+ GhcPlugins: cloneTyVarBndrs :: TCvSubst -> [TyVar] -> UniqSupply -> (TCvSubst, [TyVar])
+ GhcPlugins: closeOverKinds :: TyVarSet -> TyVarSet
+ GhcPlugins: closeOverKindsList :: [TyVar] -> [TyVar]
+ GhcPlugins: clsName :: NameSpace
+ GhcPlugins: coAxNthLHS :: CoAxiom br -> Int -> Type
+ GhcPlugins: coVarKind :: CoVar -> Type
+ GhcPlugins: coVarKindsTypesRole :: CoVar -> (Kind, Kind, Type, Type, Role)
+ GhcPlugins: coVarName :: CoVar -> Name
+ GhcPlugins: coVarRole :: CoVar -> Role
+ GhcPlugins: coVarTypes :: CoVar -> Pair Type
+ GhcPlugins: coVarsOfCo :: Coercion -> CoVarSet
+ GhcPlugins: coVarsOfType :: Type -> CoVarSet
+ GhcPlugins: coVarsOfTypes :: [Type] -> TyCoVarSet
+ GhcPlugins: coercionKind :: Coercion -> Pair Type
+ GhcPlugins: coercionKindRole :: Coercion -> (Pair Type, Role)
+ GhcPlugins: coercionKinds :: [Coercion] -> Pair [Type]
+ GhcPlugins: coercionRole :: Coercion -> Role
+ GhcPlugins: coercionSize :: Coercion -> Int
+ GhcPlugins: coercionType :: Coercion -> Type
+ GhcPlugins: compareFixity :: Fixity -> Fixity -> (Bool, Bool)
+ GhcPlugins: competesWith :: Activation -> Activation -> Bool
+ GhcPlugins: composeSteppers :: NormaliseStepper ev -> NormaliseStepper ev -> NormaliseStepper ev
+ GhcPlugins: composeTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst
+ GhcPlugins: composeTCvSubstEnv :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv)
+ GhcPlugins: coreView :: Type -> Maybe Type
+ GhcPlugins: dVarSetElemsWellScoped :: DVarSet -> [Var]
+ GhcPlugins: data Activation
+ GhcPlugins: data ArgFlag
+ GhcPlugins: data Boxity
+ GhcPlugins: data BuiltInSyntax
+ GhcPlugins: data Coercion
+ GhcPlugins: data CoercionHole
+ GhcPlugins: data CompilerPhase
+ GhcPlugins: data DefMethSpec ty
+ GhcPlugins: data DerivStrategy
+ GhcPlugins: data EP a
+ GhcPlugins: data EqRel
+ GhcPlugins: data Fixity
+ GhcPlugins: data FixityDirection
+ GhcPlugins: data FractionalLit
+ GhcPlugins: data FunctionOrData
+ GhcPlugins: data InScopeSet
+ GhcPlugins: data InlinePragma
+ GhcPlugins: data InlineSpec
+ GhcPlugins: data IntWithInf
+ GhcPlugins: data IntegralLit
+ GhcPlugins: data LeftOrRight
+ GhcPlugins: data LexicalFixity
+ GhcPlugins: data LiftingContext
+ GhcPlugins: data Name
+ GhcPlugins: data NameSpace
+ GhcPlugins: data NormaliseStepResult ev
+ GhcPlugins: data OccEnv a
+ GhcPlugins: data OccInfo
+ GhcPlugins: data OccName
+ GhcPlugins: data OneShotInfo
+ GhcPlugins: data Origin
+ GhcPlugins: data OverlapFlag
+ GhcPlugins: data OverlapMode
+ GhcPlugins: data PredTree
+ GhcPlugins: data RecFlag
+ GhcPlugins: data Role
+ GhcPlugins: data RuleMatchInfo
+ GhcPlugins: data SourceText
+ GhcPlugins: data SpliceExplicitFlag
+ GhcPlugins: data StringLiteral
+ GhcPlugins: data Subst
+ GhcPlugins: data SuccessFlag
+ GhcPlugins: data SwapFlag
+ GhcPlugins: data TCvSubst
+ GhcPlugins: data TailCallInfo
+ GhcPlugins: data TopLevelFlag
+ GhcPlugins: data TupleSort
+ GhcPlugins: data TyBinder
+ GhcPlugins: data TyCoMapper env m
+ GhcPlugins: data TyPrec
+ GhcPlugins: data TyThing
+ GhcPlugins: data Type
+ GhcPlugins: data Unique
+ GhcPlugins: data UnivCoProvenance
+ GhcPlugins: data Var
+ GhcPlugins: data WarningTxt
+ GhcPlugins: dataName :: NameSpace
+ GhcPlugins: deShadowBinds :: CoreProgram -> CoreProgram
+ GhcPlugins: decomposeCo :: Arity -> Coercion -> [Coercion]
+ GhcPlugins: decomposeFunCo :: Coercion -> (Coercion, Coercion)
+ GhcPlugins: defaultFixity :: Fixity
+ GhcPlugins: defaultInlinePragma :: InlinePragma
+ GhcPlugins: delBndr :: Subst -> Var -> Subst
+ GhcPlugins: delBndrs :: Subst -> [Var] -> Subst
+ GhcPlugins: delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
+ GhcPlugins: delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
+ GhcPlugins: demoteOccName :: OccName -> Maybe OccName
+ GhcPlugins: dfunInlinePragma :: InlinePragma
+ GhcPlugins: downgradeRole :: Role -> Role -> Coercion -> Coercion
+ GhcPlugins: dropForAlls :: Type -> Type
+ GhcPlugins: dropRuntimeRepArgs :: [Type] -> [Type]
+ GhcPlugins: elemOccEnv :: OccName -> OccEnv a -> Bool
+ GhcPlugins: elemOccSet :: OccName -> OccSet -> Bool
+ GhcPlugins: emptyCvSubstEnv :: CvSubstEnv
+ GhcPlugins: emptyFsEnv :: FastStringEnv a
+ GhcPlugins: emptyLiftingContext :: InScopeSet -> LiftingContext
+ GhcPlugins: emptyOccEnv :: OccEnv a
+ GhcPlugins: emptyOccSet :: OccSet
+ GhcPlugins: emptySubst :: Subst
+ GhcPlugins: emptyTCvSubst :: TCvSubst
+ GhcPlugins: emptyTidyOccEnv :: TidyOccEnv
+ GhcPlugins: emptyTvSubstEnv :: TvSubstEnv
+ GhcPlugins: eqCoercion :: Coercion -> Coercion -> Bool
+ GhcPlugins: eqCoercionX :: RnEnv2 -> Coercion -> Coercion -> Bool
+ GhcPlugins: eqRelRole :: EqRel -> Role
+ GhcPlugins: eqType :: Type -> Type -> Bool
+ GhcPlugins: eqTypeX :: RnEnv2 -> Type -> Type -> Bool
+ GhcPlugins: eqTypes :: [Type] -> [Type] -> Bool
+ GhcPlugins: eqVarBndrs :: RnEnv2 -> [Var] -> [Var] -> Maybe RnEnv2
+ GhcPlugins: equalityTyCon :: Role -> TyCon
+ GhcPlugins: expandTypeSynonyms :: Type -> Type
+ GhcPlugins: extendCvSubst :: TCvSubst -> CoVar -> Coercion -> TCvSubst
+ GhcPlugins: extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
+ GhcPlugins: extendIdSubst :: Subst -> Id -> CoreExpr -> Subst
+ GhcPlugins: extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst
+ GhcPlugins: extendInScope :: Subst -> Var -> Subst
+ GhcPlugins: extendInScopeIds :: Subst -> [Id] -> Subst
+ GhcPlugins: extendInScopeList :: Subst -> [Var] -> Subst
+ GhcPlugins: extendLiftingContext :: LiftingContext -> TyVar -> Coercion -> LiftingContext
+ GhcPlugins: extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
+ GhcPlugins: extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
+ GhcPlugins: extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
+ GhcPlugins: extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a
+ GhcPlugins: extendOccSet :: OccSet -> OccName -> OccSet
+ GhcPlugins: extendOccSetList :: OccSet -> [OccName] -> OccSet
+ GhcPlugins: extendSubst :: Subst -> Var -> CoreArg -> Subst
+ GhcPlugins: extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst
+ GhcPlugins: extendSubstWithVar :: Subst -> Var -> Var -> Subst
+ GhcPlugins: extendTCvInScope :: TCvSubst -> Var -> TCvSubst
+ GhcPlugins: extendTCvInScopeList :: TCvSubst -> [Var] -> TCvSubst
+ GhcPlugins: extendTCvInScopeSet :: TCvSubst -> VarSet -> TCvSubst
+ GhcPlugins: extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst
+ GhcPlugins: extendTvSubst :: Subst -> TyVar -> Type -> Subst
+ GhcPlugins: extendTvSubstAndInScope :: TCvSubst -> TyVar -> Type -> TCvSubst
+ GhcPlugins: extendTvSubstBinderAndInScope :: TCvSubst -> TyBinder -> Type -> TCvSubst
+ GhcPlugins: extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst
+ GhcPlugins: extendTvSubstWithClone :: TCvSubst -> TyVar -> TyVar -> TCvSubst
+ GhcPlugins: fIRST_TAG :: ConTag
+ GhcPlugins: failed :: SuccessFlag -> Bool
+ GhcPlugins: filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
+ GhcPlugins: filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet
+ GhcPlugins: filterOutInvisibleTypes :: TyCon -> [Type] -> [Type]
+ GhcPlugins: flipSwap :: SwapFlag -> SwapFlag
+ GhcPlugins: foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
+ GhcPlugins: funArgTy :: Type -> Type
+ GhcPlugins: funResultTy :: Type -> Type
+ GhcPlugins: funTyCon :: TyCon
+ GhcPlugins: funTyFixity :: Fixity
+ GhcPlugins: getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)
+ GhcPlugins: getClassPredTys :: PredType -> (Class, [Type])
+ GhcPlugins: getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])
+ GhcPlugins: getCoVar_maybe :: Coercion -> Maybe CoVar
+ GhcPlugins: getCvSubstEnv :: TCvSubst -> CvSubstEnv
+ GhcPlugins: getEqPredRole :: PredType -> Role
+ GhcPlugins: getEqPredTys :: PredType -> (Type, Type)
+ GhcPlugins: getEqPredTys_maybe :: PredType -> Maybe (Role, Type, Type)
+ GhcPlugins: getName :: NamedThing a => a -> Name
+ GhcPlugins: getOccFS :: NamedThing a => a -> FastString
+ GhcPlugins: getOccName :: NamedThing a => a -> OccName
+ GhcPlugins: getOccString :: NamedThing a => a -> String
+ GhcPlugins: getRuntimeRep :: HasDebugCallStack => Type -> Type
+ GhcPlugins: getRuntimeRepFromKind :: HasDebugCallStack => Type -> Type
+ GhcPlugins: getRuntimeRepFromKind_maybe :: HasDebugCallStack => Type -> Maybe Type
+ GhcPlugins: getRuntimeRep_maybe :: HasDebugCallStack => Type -> Maybe Type
+ GhcPlugins: getSrcLoc :: NamedThing a => a -> SrcLoc
+ GhcPlugins: getSrcSpan :: NamedThing a => a -> SrcSpan
+ GhcPlugins: getTCvInScope :: TCvSubst -> InScopeSet
+ GhcPlugins: getTCvSubst :: Subst -> TCvSubst
+ GhcPlugins: getTCvSubstRangeFVs :: TCvSubst -> VarSet
+ GhcPlugins: getTvSubstEnv :: TCvSubst -> TvSubstEnv
+ GhcPlugins: getTyVar :: String -> Type -> TyVar
+ GhcPlugins: getTyVar_maybe :: Type -> Maybe TyVar
+ GhcPlugins: getUnique :: Uniquable a => a -> Unique
+ GhcPlugins: globaliseId :: Id -> Id
+ GhcPlugins: hasIncoherentFlag :: OverlapMode -> Bool
+ GhcPlugins: hasNoBinding :: Id -> Bool
+ GhcPlugins: hasNoOneShotInfo :: OneShotInfo -> Bool
+ GhcPlugins: hasOverlappableFlag :: OverlapMode -> Bool
+ GhcPlugins: hasOverlappingFlag :: OverlapMode -> Bool
+ GhcPlugins: idArity :: Id -> Arity
+ GhcPlugins: idCafInfo :: Id -> CafInfo
+ GhcPlugins: idCallArity :: Id -> Arity
+ GhcPlugins: idCoreRules :: Id -> [CoreRule]
+ GhcPlugins: idDataCon :: Id -> DataCon
+ GhcPlugins: idDemandInfo :: Id -> Demand
+ GhcPlugins: idDetails :: Id -> IdDetails
+ GhcPlugins: idFunRepArity :: Id -> RepArity
+ GhcPlugins: idHasRules :: Id -> Bool
+ GhcPlugins: idInfo :: HasDebugCallStack => Id -> IdInfo
+ GhcPlugins: idInlineActivation :: Id -> Activation
+ GhcPlugins: idInlinePragma :: Id -> InlinePragma
+ GhcPlugins: idIsFrom :: Module -> Id -> Bool
+ GhcPlugins: idJoinArity :: JoinId -> JoinArity
+ GhcPlugins: idName :: Id -> Name
+ GhcPlugins: idOccInfo :: Id -> OccInfo
+ GhcPlugins: idOneShotInfo :: Id -> OneShotInfo
+ GhcPlugins: idRuleMatchInfo :: Id -> RuleMatchInfo
+ GhcPlugins: idSpecialisation :: Id -> RuleInfo
+ GhcPlugins: idStateHackOneShotInfo :: Id -> OneShotInfo
+ GhcPlugins: idStrictness :: Id -> StrictSig
+ GhcPlugins: idType :: Id -> Kind
+ GhcPlugins: idUnfolding :: Id -> Unfolding
+ GhcPlugins: idUnique :: Id -> Unique
+ GhcPlugins: infinity :: IntWithInf
+ GhcPlugins: infixl 1 `setIdOneShotInfo`
+ GhcPlugins: infixl 5 `mkCoherenceLeftCo`
+ GhcPlugins: infixr 3 `mkFunTy`
+ GhcPlugins: initTidyOccEnv :: [OccName] -> TidyOccEnv
+ GhcPlugins: initialVersion :: Version
+ GhcPlugins: inlinePragmaActivation :: InlinePragma -> Activation
+ GhcPlugins: inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo
+ GhcPlugins: inlinePragmaSat :: InlinePragma -> Maybe Arity
+ GhcPlugins: inlinePragmaSpec :: InlinePragma -> InlineSpec
+ GhcPlugins: insideLam :: InsideLam
+ GhcPlugins: instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion)
+ GhcPlugins: intGtLimit :: Int -> IntWithInf -> Bool
+ GhcPlugins: integralFractionalLit :: Bool -> Integer -> FractionalLit
+ GhcPlugins: intersectOccSet :: OccSet -> OccSet -> OccSet
+ GhcPlugins: intersectsOccSet :: OccSet -> OccSet -> Bool
+ GhcPlugins: isActive :: CompilerPhase -> Activation -> Bool
+ GhcPlugins: isActiveIn :: PhaseNum -> Activation -> Bool
+ GhcPlugins: isAlgType :: Type -> Bool
+ GhcPlugins: isAlwaysActive :: Activation -> Bool
+ GhcPlugins: isAlwaysTailCalled :: OccInfo -> Bool
+ GhcPlugins: isAnonTyBinder :: TyBinder -> Bool
+ GhcPlugins: isAnyInlinePragma :: InlinePragma -> Bool
+ GhcPlugins: isBottomingId :: Var -> Bool
+ GhcPlugins: isBoxed :: Boxity -> Bool
+ GhcPlugins: isBuiltInSyntax :: Name -> Bool
+ GhcPlugins: isCTupleClass :: Class -> Bool
+ GhcPlugins: isClassOpId_maybe :: Id -> Maybe Class
+ GhcPlugins: isClassPred :: PredType -> Bool
+ GhcPlugins: isCoVar :: Var -> Bool
+ GhcPlugins: isCoVar_maybe :: Coercion -> Maybe CoVar
+ GhcPlugins: isCoercionTy :: Type -> Bool
+ GhcPlugins: isCoercionTy_maybe :: Type -> Maybe Coercion
+ GhcPlugins: isCoercionType :: Type -> Bool
+ GhcPlugins: isConLike :: RuleMatchInfo -> Bool
+ GhcPlugins: isConLikeId :: Id -> Bool
+ GhcPlugins: isDFunId :: Id -> Bool
+ GhcPlugins: isDataConId_maybe :: Id -> Maybe DataCon
+ GhcPlugins: isDataConName :: Name -> Bool
+ GhcPlugins: isDataConNameSpace :: NameSpace -> Bool
+ GhcPlugins: isDataConRecordSelector :: Id -> Bool
+ GhcPlugins: isDataConWorkId :: Id -> Bool
+ GhcPlugins: isDataConWorkId_maybe :: Id -> Maybe DataCon
+ GhcPlugins: isDataFamilyAppType :: Type -> Bool
+ GhcPlugins: isDataOcc :: OccName -> Bool
+ GhcPlugins: isDataSymOcc :: OccName -> Bool
+ GhcPlugins: isDeadBinder :: Id -> Bool
+ GhcPlugins: isDeadOcc :: OccInfo -> Bool
+ GhcPlugins: isDefaultInlinePragma :: InlinePragma -> Bool
+ GhcPlugins: isDefaultMethodOcc :: OccName -> Bool
+ GhcPlugins: isDerivedOccName :: OccName -> Bool
+ GhcPlugins: isDictId :: Id -> Bool
+ GhcPlugins: isDictLikeTy :: Type -> Bool
+ GhcPlugins: isDictTy :: Type -> Bool
+ GhcPlugins: isEarlyActive :: Activation -> Bool
+ GhcPlugins: isEmptyOccSet :: OccSet -> Bool
+ GhcPlugins: isEmptySubst :: Subst -> Bool
+ GhcPlugins: isEmptyTCvSubst :: TCvSubst -> Bool
+ GhcPlugins: isEqPred :: PredType -> Bool
+ GhcPlugins: isEvVar :: Var -> Bool
+ GhcPlugins: isExitJoinId :: Var -> Bool
+ GhcPlugins: isExportedId :: Var -> Bool
+ GhcPlugins: isExternalName :: Name -> Bool
+ GhcPlugins: isFCallId :: Id -> Bool
+ GhcPlugins: isFCallId_maybe :: Id -> Maybe ForeignCall
+ GhcPlugins: isFamFreeTy :: Type -> Bool
+ GhcPlugins: isForAllTy :: Type -> Bool
+ GhcPlugins: isFunLike :: RuleMatchInfo -> Bool
+ GhcPlugins: isFunTy :: Type -> Bool
+ GhcPlugins: isGenerated :: Origin -> Bool
+ GhcPlugins: isGlobalId :: Var -> Bool
+ GhcPlugins: isHoleName :: Name -> Bool
+ GhcPlugins: isIPClass :: Class -> Bool
+ GhcPlugins: isIPPred :: PredType -> Bool
+ GhcPlugins: isIPPred_maybe :: Type -> Maybe (FastString, Type)
+ GhcPlugins: isIPTyCon :: TyCon -> Bool
+ GhcPlugins: isId :: Var -> Bool
+ GhcPlugins: isImplicitId :: Id -> Bool
+ GhcPlugins: isInScope :: Var -> Subst -> Bool
+ GhcPlugins: isInlinablePragma :: InlinePragma -> Bool
+ GhcPlugins: isInlinePragma :: InlinePragma -> Bool
+ GhcPlugins: isInternalName :: Name -> Bool
+ GhcPlugins: isInvisibleArgFlag :: ArgFlag -> Bool
+ GhcPlugins: isInvisibleBinder :: TyBinder -> Bool
+ GhcPlugins: isJoinId :: Var -> Bool
+ GhcPlugins: isJoinId_maybe :: Var -> Maybe JoinArity
+ GhcPlugins: isLiftedType_maybe :: HasDebugCallStack => Type -> Maybe Bool
+ GhcPlugins: isLocalId :: Var -> Bool
+ GhcPlugins: isManyOccs :: OccInfo -> Bool
+ GhcPlugins: isMappedByLC :: TyCoVar -> LiftingContext -> Bool
+ GhcPlugins: isNamedTyBinder :: TyBinder -> Bool
+ GhcPlugins: isNaughtyRecordSelector :: Id -> Bool
+ GhcPlugins: isNeverActive :: Activation -> Bool
+ GhcPlugins: isNeverLevPolyId :: Id -> Bool
+ GhcPlugins: isNomEqPred :: PredType -> Bool
+ GhcPlugins: isNonRec :: RecFlag -> Bool
+ GhcPlugins: isNotTopLevel :: TopLevelFlag -> Bool
+ GhcPlugins: isNumLitTy :: Type -> Maybe Integer
+ GhcPlugins: isOneOcc :: OccInfo -> Bool
+ GhcPlugins: isOneShotBndr :: Var -> Bool
+ GhcPlugins: isOneShotInfo :: OneShotInfo -> Bool
+ GhcPlugins: isPatSynRecordSelector :: Id -> Bool
+ GhcPlugins: isPiTy :: Type -> Bool
+ GhcPlugins: isPredTy :: Type -> Bool
+ GhcPlugins: isPrimOpId :: Id -> Bool
+ GhcPlugins: isPrimOpId_maybe :: Id -> Maybe PrimOp
+ GhcPlugins: isPrimitiveType :: Type -> Bool
+ GhcPlugins: isProbablyOneShotLambda :: Id -> Bool
+ GhcPlugins: isRec :: RecFlag -> Bool
+ GhcPlugins: isRecordSelector :: Id -> Bool
+ GhcPlugins: isReflCo :: Coercion -> Bool
+ GhcPlugins: isReflCoVar_maybe :: CoVar -> Maybe Coercion
+ GhcPlugins: isReflCo_maybe :: Coercion -> Maybe (Type, Role)
+ GhcPlugins: isReflexiveCo :: Coercion -> Bool
+ GhcPlugins: isReflexiveCo_maybe :: Coercion -> Maybe (Type, Role)
+ GhcPlugins: isRuntimeRepKindedTy :: Type -> Bool
+ GhcPlugins: isRuntimeRepTy :: Type -> Bool
+ GhcPlugins: isRuntimeRepVar :: TyVar -> Bool
+ GhcPlugins: isStateHackType :: Type -> Bool
+ GhcPlugins: isStrLitTy :: Type -> Maybe FastString
+ GhcPlugins: isStrictId :: Id -> Bool
+ GhcPlugins: isStrictType :: HasDebugCallStack => Type -> Bool
+ GhcPlugins: isStrongLoopBreaker :: OccInfo -> Bool
+ GhcPlugins: isSwapped :: SwapFlag -> Bool
+ GhcPlugins: isSymOcc :: OccName -> Bool
+ GhcPlugins: isSystemName :: Name -> Bool
+ GhcPlugins: isTauTy :: Type -> Bool
+ GhcPlugins: isTcClsNameSpace :: NameSpace -> Bool
+ GhcPlugins: isTcOcc :: OccName -> Bool
+ GhcPlugins: isTopLevel :: TopLevelFlag -> Bool
+ GhcPlugins: isTvNameSpace :: NameSpace -> Bool
+ GhcPlugins: isTvOcc :: OccName -> Bool
+ GhcPlugins: isTyConName :: Name -> Bool
+ GhcPlugins: isTyVar :: Var -> Bool
+ GhcPlugins: isTyVarName :: Name -> Bool
+ GhcPlugins: isTyVarTy :: Type -> Bool
+ GhcPlugins: isTypeLevPoly :: Type -> Bool
+ GhcPlugins: isTypeableBindOcc :: OccName -> Bool
+ GhcPlugins: isUnboxedSumType :: Type -> Bool
+ GhcPlugins: isUnboxedTupleType :: Type -> Bool
+ GhcPlugins: isUnliftedType :: HasDebugCallStack => Type -> Bool
+ GhcPlugins: isValName :: Name -> Bool
+ GhcPlugins: isValNameSpace :: NameSpace -> Bool
+ GhcPlugins: isValOcc :: OccName -> Bool
+ GhcPlugins: isValidJoinPointType :: JoinArity -> Type -> Bool
+ GhcPlugins: isVarName :: Name -> Bool
+ GhcPlugins: isVarNameSpace :: NameSpace -> Bool
+ GhcPlugins: isVarOcc :: OccName -> Bool
+ GhcPlugins: isVisibleArgFlag :: ArgFlag -> Bool
+ GhcPlugins: isVisibleBinder :: TyBinder -> Bool
+ GhcPlugins: isWeakLoopBreaker :: OccInfo -> Bool
+ GhcPlugins: isWiredInName :: Name -> Bool
+ GhcPlugins: lcInScopeSet :: LiftingContext -> InScopeSet
+ GhcPlugins: lcSubstLeft :: LiftingContext -> TCvSubst
+ GhcPlugins: lcSubstRight :: LiftingContext -> TCvSubst
+ GhcPlugins: lcTCvSubst :: LiftingContext -> TCvSubst
+ GhcPlugins: liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion
+ GhcPlugins: liftCoSubstTyVar :: LiftingContext -> Role -> TyVar -> Maybe Coercion
+ GhcPlugins: liftCoSubstVarBndrCallback :: (LiftingContext -> Type -> (Coercion, a)) -> LiftingContext -> TyVar -> (LiftingContext, TyVar, Coercion, a)
+ GhcPlugins: liftCoSubstWith :: Role -> [TyCoVar] -> [Coercion] -> Type -> Coercion
+ GhcPlugins: liftCoSubstWithEx :: Role -> [TyVar] -> [Coercion] -> [TyVar] -> [Type] -> (Type -> Coercion, [Type])
+ GhcPlugins: liftEnvSubstLeft :: TCvSubst -> LiftCoEnv -> TCvSubst
+ GhcPlugins: liftEnvSubstRight :: TCvSubst -> LiftCoEnv -> TCvSubst
+ GhcPlugins: liftedTypeKind :: Kind
+ GhcPlugins: localiseId :: Id -> Id
+ GhcPlugins: localiseName :: Name -> Name
+ GhcPlugins: lookupCoVar :: TCvSubst -> Var -> Maybe Coercion
+ GhcPlugins: lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
+ GhcPlugins: lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr
+ GhcPlugins: lookupOccEnv :: OccEnv a -> OccName -> Maybe a
+ GhcPlugins: lookupTCvSubst :: Subst -> TyVar -> Type
+ GhcPlugins: lookupTyVar :: TCvSubst -> TyVar -> Maybe Type
+ GhcPlugins: ltRole :: Role -> Role -> Bool
+ GhcPlugins: mapCoercion :: Monad m => TyCoMapper env m -> env -> Coercion -> m Coercion
+ GhcPlugins: mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b
+ GhcPlugins: mapStepResult :: (ev1 -> ev2) -> NormaliseStepResult ev1 -> NormaliseStepResult ev2
+ GhcPlugins: mapType :: Monad m => TyCoMapper env m -> env -> Type -> m Type
+ GhcPlugins: maxPrecedence :: Int
+ GhcPlugins: maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
+ GhcPlugins: maybeParen :: TyPrec -> TyPrec -> SDoc -> SDoc
+ GhcPlugins: maybeSubCo :: EqRel -> Coercion -> Coercion
+ GhcPlugins: minPrecedence :: Int
+ GhcPlugins: minusOccSet :: OccSet -> OccSet -> OccSet
+ GhcPlugins: mkAnonBinder :: Type -> TyBinder
+ GhcPlugins: mkAppCo :: Coercion -> Coercion -> Coercion
+ GhcPlugins: mkAppCos :: Coercion -> [Coercion] -> Coercion
+ GhcPlugins: mkAppTy :: Type -> Type -> Type
+ GhcPlugins: mkAppTys :: Type -> [Type] -> Type
+ GhcPlugins: mkAxInstCo :: Role -> CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Coercion
+ GhcPlugins: mkAxInstLHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
+ GhcPlugins: mkAxInstRHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
+ GhcPlugins: mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion
+ GhcPlugins: mkAxiomRuleCo :: CoAxiomRule -> [Coercion] -> Coercion
+ GhcPlugins: mkBuilderOcc :: OccName -> OccName
+ GhcPlugins: mkCastTy :: Type -> Coercion -> Type
+ GhcPlugins: mkClassDataConOcc :: OccName -> OccName
+ GhcPlugins: mkClassOpAuxOcc :: OccName -> OccName
+ GhcPlugins: mkClassPred :: Class -> [Type] -> PredType
+ GhcPlugins: mkClonedInternalName :: Unique -> Name -> Name
+ GhcPlugins: mkClsOcc :: String -> OccName
+ GhcPlugins: mkClsOccFS :: FastString -> OccName
+ GhcPlugins: mkCoCast :: Coercion -> Coercion -> Coercion
+ GhcPlugins: mkCoVar :: Name -> Type -> CoVar
+ GhcPlugins: mkCoVarCo :: CoVar -> Coercion
+ GhcPlugins: mkCoVarCos :: [CoVar] -> [Coercion]
+ GhcPlugins: mkCoercionTy :: Coercion -> Type
+ GhcPlugins: mkCoercionType :: Role -> Type -> Type -> Type
+ GhcPlugins: mkCoherenceCo :: Coercion -> Coercion -> Coercion
+ GhcPlugins: mkCoherenceLeftCo :: Coercion -> Coercion -> Coercion
+ GhcPlugins: mkCoherenceRightCo :: Coercion -> Coercion -> Coercion
+ GhcPlugins: mkCon2TagOcc :: OccName -> OccName
+ GhcPlugins: mkDFunOcc :: String -> Bool -> OccSet -> OccName
+ GhcPlugins: mkDataCOcc :: OccName -> OccSet -> OccName
+ GhcPlugins: mkDataConWorkerOcc :: OccName -> OccName
+ GhcPlugins: mkDataConWrapperOcc :: OccName -> OccName
+ GhcPlugins: mkDataOcc :: String -> OccName
+ GhcPlugins: mkDataOccFS :: FastString -> OccName
+ GhcPlugins: mkDataTOcc :: OccName -> OccSet -> OccName
+ GhcPlugins: mkDefaultMethodOcc :: OccName -> OccName
+ GhcPlugins: mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
+ GhcPlugins: mkDictOcc :: OccName -> OccName
+ GhcPlugins: mkEmptySubst :: InScopeSet -> Subst
+ GhcPlugins: mkEmptyTCvSubst :: InScopeSet -> TCvSubst
+ GhcPlugins: mkEqPredCoOcc :: OccName -> OccName
+ GhcPlugins: mkExportedLocalId :: IdDetails -> Name -> Type -> Id
+ GhcPlugins: mkExportedVanillaId :: Name -> Type -> Id
+ GhcPlugins: mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
+ GhcPlugins: mkFCallName :: Unique -> String -> Name
+ GhcPlugins: mkFamilyTyConApp :: TyCon -> [Type] -> Type
+ GhcPlugins: mkForAllCo :: TyVar -> Coercion -> Coercion -> Coercion
+ GhcPlugins: mkForAllCos :: [(TyVar, Coercion)] -> Coercion -> Coercion
+ GhcPlugins: mkForAllTy :: TyVar -> ArgFlag -> Type -> Type
+ GhcPlugins: mkForAllTys :: [TyVarBinder] -> Type -> Type
+ GhcPlugins: mkForeignExportOcc :: OccName -> OccName
+ GhcPlugins: mkFractionalLit :: Real a => a -> FractionalLit
+ GhcPlugins: mkFsEnv :: [(FastString, a)] -> FastStringEnv a
+ GhcPlugins: mkFunCo :: Role -> Coercion -> Coercion -> Coercion
+ GhcPlugins: mkFunCos :: Role -> [Coercion] -> Coercion -> Coercion
+ GhcPlugins: mkFunTy :: Type -> Type -> Type
+ GhcPlugins: mkFunTys :: [Type] -> Type -> Type
+ GhcPlugins: mkGen1R :: OccName -> OccName
+ GhcPlugins: mkGenR :: OccName -> OccName
+ GhcPlugins: mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id
+ GhcPlugins: mkHeteroCoercionType :: Role -> Kind -> Kind -> Type -> Type -> Type
+ GhcPlugins: mkHeteroPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
+ GhcPlugins: mkHeteroReprPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
+ GhcPlugins: mkHoleCo :: CoercionHole -> Coercion
+ GhcPlugins: mkHomoForAllCos :: [TyVar] -> Coercion -> Coercion
+ GhcPlugins: mkHomoForAllCos_NoRefl :: [TyVar] -> Coercion -> Coercion
+ GhcPlugins: mkHomoPhantomCo :: Type -> Type -> Coercion
+ GhcPlugins: mkIPOcc :: OccName -> OccName
+ GhcPlugins: mkInstCo :: Coercion -> Coercion -> Coercion
+ GhcPlugins: mkInstTyCoOcc :: OccName -> OccName
+ GhcPlugins: mkInstTyTcOcc :: String -> OccSet -> OccName
+ GhcPlugins: mkIntWithInf :: Int -> IntWithInf
+ GhcPlugins: mkIntegralLit :: Integral a => a -> IntegralLit
+ GhcPlugins: mkInternalName :: Unique -> OccName -> SrcSpan -> Name
+ GhcPlugins: mkInvForAllTy :: TyVar -> Type -> Type
+ GhcPlugins: mkInvForAllTys :: [TyVar] -> Type -> Type
+ GhcPlugins: mkKindCo :: Coercion -> Coercion
+ GhcPlugins: mkLRCo :: LeftOrRight -> Coercion -> Coercion
+ GhcPlugins: mkLamType :: Var -> Type -> Type
+ GhcPlugins: mkLamTypes :: [Var] -> Type -> Type
+ GhcPlugins: mkLocalCoVar :: Name -> Type -> CoVar
+ GhcPlugins: mkLocalId :: Name -> Type -> Id
+ GhcPlugins: mkLocalIdOrCoVar :: Name -> Type -> Id
+ GhcPlugins: mkLocalIdOrCoVarWithInfo :: Name -> Type -> IdInfo -> Id
+ GhcPlugins: mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
+ GhcPlugins: mkLocalOcc :: Unique -> OccName -> OccName
+ GhcPlugins: mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName
+ GhcPlugins: mkMatcherOcc :: OccName -> OccName
+ GhcPlugins: mkMaxTagOcc :: OccName -> OccName
+ GhcPlugins: mkMethodOcc :: OccName -> OccName
+ GhcPlugins: mkNewTyCoOcc :: OccName -> OccName
+ GhcPlugins: mkNomReflCo :: Type -> Coercion
+ GhcPlugins: mkNthCo :: Int -> Coercion -> Coercion
+ GhcPlugins: mkNthCoRole :: Role -> Int -> Coercion -> Coercion
+ GhcPlugins: mkNumLitTy :: Integer -> Type
+ GhcPlugins: mkOccEnv :: [(OccName, a)] -> OccEnv a
+ GhcPlugins: mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a
+ GhcPlugins: mkOccName :: NameSpace -> String -> OccName
+ GhcPlugins: mkOccNameFS :: NameSpace -> FastString -> OccName
+ GhcPlugins: mkOccSet :: [OccName] -> OccSet
+ GhcPlugins: mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst
+ GhcPlugins: mkPADFunOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkPDataDataConOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkPDataTyConOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkPDatasDataConOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkPDatasTyConOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkPReprTyConOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkPhantomCo :: Coercion -> Type -> Type -> Coercion
+ GhcPlugins: mkPiCo :: Role -> Var -> Coercion -> Coercion
+ GhcPlugins: mkPiCos :: Role -> [Var] -> Coercion -> Coercion
+ GhcPlugins: mkPiTy :: TyBinder -> Type -> Type
+ GhcPlugins: mkPiTys :: [TyBinder] -> Type -> Type
+ GhcPlugins: mkPrimEqPred :: Type -> Type -> Type
+ GhcPlugins: mkPrimEqPredRole :: Role -> Type -> Type -> PredType
+ GhcPlugins: mkProofIrrelCo :: Role -> Coercion -> Coercion -> Coercion -> Coercion
+ GhcPlugins: mkRecFldSelOcc :: String -> OccName
+ GhcPlugins: mkReflCo :: Role -> Type -> Coercion
+ GhcPlugins: mkRepEqOcc :: OccName -> OccName
+ GhcPlugins: mkRepReflCo :: Type -> Coercion
+ GhcPlugins: mkReprPrimEqPred :: Type -> Type -> Type
+ GhcPlugins: mkSpecForAllTys :: [TyVar] -> Type -> Type
+ GhcPlugins: mkSpecOcc :: OccName -> OccName
+ GhcPlugins: mkStrLitTy :: FastString -> Type
+ GhcPlugins: mkSubCo :: Coercion -> Coercion
+ GhcPlugins: mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst
+ GhcPlugins: mkSubstLiftingContext :: TCvSubst -> LiftingContext
+ GhcPlugins: mkSuperDictAuxOcc :: Int -> OccName -> OccName
+ GhcPlugins: mkSuperDictSelOcc :: Int -> OccName -> OccName
+ GhcPlugins: mkSymCo :: Coercion -> Coercion
+ GhcPlugins: mkSysLocal :: FastString -> Unique -> Type -> Id
+ GhcPlugins: mkSysLocalM :: MonadUnique m => FastString -> Type -> m Id
+ GhcPlugins: mkSysLocalOrCoVar :: FastString -> Unique -> Type -> Id
+ GhcPlugins: mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Type -> m Id
+ GhcPlugins: mkSysTvName :: Unique -> FastString -> Name
+ GhcPlugins: mkSystemName :: Unique -> OccName -> Name
+ GhcPlugins: mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
+ GhcPlugins: mkSystemVarName :: Unique -> FastString -> Name
+ GhcPlugins: mkTCvSubst :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> TCvSubst
+ GhcPlugins: mkTag2ConOcc :: OccName -> OccName
+ GhcPlugins: mkTcOcc :: String -> OccName
+ GhcPlugins: mkTcOccFS :: FastString -> OccName
+ GhcPlugins: mkTemplateLocal :: Int -> Type -> Id
+ GhcPlugins: mkTemplateLocals :: [Type] -> [Id]
+ GhcPlugins: mkTemplateLocalsNum :: Int -> [Type] -> [Id]
+ GhcPlugins: mkTransAppCo :: Role -> Coercion -> Type -> Type -> Role -> Coercion -> Type -> Type -> Role -> Coercion
+ GhcPlugins: mkTransCo :: Coercion -> Coercion -> Coercion
+ GhcPlugins: mkTvSubstPrs :: [(TyVar, Type)] -> TCvSubst
+ GhcPlugins: mkTyBinderTyConBinder :: TyBinder -> SrcSpan -> Unique -> OccName -> TyConBinder
+ GhcPlugins: mkTyConApp :: TyCon -> [Type] -> Type
+ GhcPlugins: mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion
+ GhcPlugins: mkTyConBindersPreferAnon :: [TyVar] -> Type -> [TyConBinder]
+ GhcPlugins: mkTyConRepOcc :: OccName -> OccName
+ GhcPlugins: mkTyConTy :: TyCon -> Type
+ GhcPlugins: mkTyVarBinder :: ArgFlag -> Var -> TyVarBinder
+ GhcPlugins: mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder]
+ GhcPlugins: mkTyVarOcc :: String -> OccName
+ GhcPlugins: mkTyVarOccFS :: FastString -> OccName
+ GhcPlugins: mkTyVarTy :: TyVar -> Type
+ GhcPlugins: mkTyVarTys :: [TyVar] -> [Type]
+ GhcPlugins: mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> [Coercion] -> Coercion
+ GhcPlugins: mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
+ GhcPlugins: mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
+ GhcPlugins: mkUnivCo :: UnivCoProvenance -> Role -> Type -> Type -> Coercion
+ GhcPlugins: mkUnsafeCo :: Role -> Type -> Type -> Coercion
+ GhcPlugins: mkUserLocal :: OccName -> Unique -> Type -> SrcSpan -> Id
+ GhcPlugins: mkUserLocalOrCoVar :: OccName -> Unique -> Type -> SrcSpan -> Id
+ GhcPlugins: mkVanillaGlobal :: Name -> Type -> Id
+ GhcPlugins: mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id
+ GhcPlugins: mkVarOcc :: String -> OccName
+ GhcPlugins: mkVarOccFS :: FastString -> OccName
+ GhcPlugins: mkVectDataConOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkVectIsoOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkVectOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkVectTyConOcc :: Maybe String -> OccName -> OccName
+ GhcPlugins: mkVisForAllTys :: [TyVar] -> Type -> Type
+ GhcPlugins: mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
+ GhcPlugins: mkWorkerId :: Unique -> Id -> Type -> Id
+ GhcPlugins: mkWorkerOcc :: OccName -> OccName
+ GhcPlugins: modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
+ GhcPlugins: modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
+ GhcPlugins: modifyJoinResTy :: Int -> (Type -> Type) -> Type -> Type
+ GhcPlugins: nameIsFromExternalPackage :: UnitId -> Name -> Bool
+ GhcPlugins: nameIsHomePackage :: Module -> Name -> Bool
+ GhcPlugins: nameIsHomePackageImport :: Module -> Name -> Bool
+ GhcPlugins: nameIsLocalOrFrom :: Module -> Name -> Bool
+ GhcPlugins: nameModule :: Name -> Module
+ GhcPlugins: nameModule_maybe :: Name -> Maybe Module
+ GhcPlugins: nameOccName :: Name -> OccName
+ GhcPlugins: nameSpacesRelated :: NameSpace -> NameSpace -> Bool
+ GhcPlugins: nameSrcLoc :: Name -> SrcLoc
+ GhcPlugins: nameSrcSpan :: Name -> SrcSpan
+ GhcPlugins: nameStableString :: Name -> String
+ GhcPlugins: nameUnique :: Name -> Unique
+ GhcPlugins: negateFixity :: Fixity
+ GhcPlugins: negateFractionalLit :: FractionalLit -> FractionalLit
+ GhcPlugins: negateIntegralLit :: IntegralLit -> IntegralLit
+ GhcPlugins: neverInlinePragma :: InlinePragma
+ GhcPlugins: newTyConInstRhs :: TyCon -> [Type] -> Type
+ GhcPlugins: nextRole :: Type -> Role
+ GhcPlugins: noFreeVarsOfType :: Type -> Bool
+ GhcPlugins: noOccInfo :: OccInfo
+ GhcPlugins: noOneShotInfo :: OneShotInfo
+ GhcPlugins: noUserInlineSpec :: InlineSpec -> Bool
+ GhcPlugins: nonDetCmpTc :: TyCon -> TyCon -> Ordering
+ GhcPlugins: nonDetCmpType :: Type -> Type -> Ordering
+ GhcPlugins: nonDetCmpTypeX :: RnEnv2 -> Type -> Type -> Ordering
+ GhcPlugins: nonDetCmpTypes :: [Type] -> [Type] -> Ordering
+ GhcPlugins: nonDetCmpTypesX :: RnEnv2 -> [Type] -> [Type] -> Ordering
+ GhcPlugins: notElemTCvSubst :: Var -> TCvSubst -> Bool
+ GhcPlugins: notInsideLam :: InsideLam
+ GhcPlugins: notOneBranch :: OneBranch
+ GhcPlugins: nthRole :: Role -> TyCon -> Int -> Role
+ GhcPlugins: occEnvElts :: OccEnv a -> [a]
+ GhcPlugins: occName :: HasOccName name => name -> OccName
+ GhcPlugins: occNameString :: OccName -> String
+ GhcPlugins: oneBranch :: OneBranch
+ GhcPlugins: parenSymOcc :: OccName -> SDoc -> SDoc
+ GhcPlugins: partitionInvisibles :: TyCon -> (a -> Type) -> [a] -> ([a], [a])
+ GhcPlugins: piResultTy :: HasDebugCallStack => Type -> Type -> Type
+ GhcPlugins: piResultTys :: HasDebugCallStack => Type -> [Type] -> Type
+ GhcPlugins: pickLR :: LeftOrRight -> (a, a) -> a
+ GhcPlugins: plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
+ GhcPlugins: plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a
+ GhcPlugins: ppSuggestExplicitKinds :: SDoc
+ GhcPlugins: pprAlternative :: (a -> SDoc) -> a -> ConTag -> Arity -> SDoc
+ GhcPlugins: pprClassPred :: Class -> [Type] -> SDoc
+ GhcPlugins: pprCo :: Coercion -> SDoc
+ GhcPlugins: pprCoAxBranch :: CoAxiom br -> CoAxBranch -> SDoc
+ GhcPlugins: pprCoAxBranchHdr :: CoAxiom br -> BranchIndex -> SDoc
+ GhcPlugins: pprCoAxiom :: CoAxiom br -> SDoc
+ GhcPlugins: pprDefinedAt :: Name -> SDoc
+ GhcPlugins: pprForAll :: [TyVarBinder] -> SDoc
+ GhcPlugins: pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc
+ GhcPlugins: pprInline :: InlinePragma -> SDoc
+ GhcPlugins: pprInlineDebug :: InlinePragma -> SDoc
+ GhcPlugins: pprKind :: Kind -> SDoc
+ GhcPlugins: pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
+ GhcPlugins: pprNameDefnLoc :: Name -> SDoc
+ GhcPlugins: pprNameSpace :: NameSpace -> SDoc
+ GhcPlugins: pprNameSpaceBrief :: NameSpace -> SDoc
+ GhcPlugins: pprNonVarNameSpace :: NameSpace -> SDoc
+ GhcPlugins: pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc
+ GhcPlugins: pprOccName :: OccName -> SDoc
+ GhcPlugins: pprParendCo :: Coercion -> SDoc
+ GhcPlugins: pprParendKind :: Kind -> SDoc
+ GhcPlugins: pprParendType :: Type -> SDoc
+ GhcPlugins: pprPrecType :: TyPrec -> Type -> SDoc
+ GhcPlugins: pprPrefixName :: NamedThing a => a -> SDoc
+ GhcPlugins: pprRuleName :: RuleName -> SDoc
+ GhcPlugins: pprShortTyThing :: TyThing -> SDoc
+ GhcPlugins: pprSigmaType :: Type -> SDoc
+ GhcPlugins: pprSourceTyCon :: TyCon -> SDoc
+ GhcPlugins: pprTheta :: ThetaType -> SDoc
+ GhcPlugins: pprThetaArrowTy :: ThetaType -> SDoc
+ GhcPlugins: pprTvBndr :: TyVarBinder -> SDoc
+ GhcPlugins: pprTvBndrs :: [TyVarBinder] -> SDoc
+ GhcPlugins: pprTyThingCategory :: TyThing -> SDoc
+ GhcPlugins: pprTyVar :: TyVar -> SDoc
+ GhcPlugins: pprTyVars :: [TyVar] -> SDoc
+ GhcPlugins: pprType :: Type -> SDoc
+ GhcPlugins: pprTypeApp :: TyCon -> [Type] -> SDoc
+ GhcPlugins: pprUserForAll :: [TyVarBinder] -> SDoc
+ GhcPlugins: pprUserTypeErrorTy :: Type -> SDoc
+ GhcPlugins: pprWarningTxtForMsg :: WarningTxt -> SDoc
+ GhcPlugins: pprWithSourceText :: SourceText -> SDoc -> SDoc
+ GhcPlugins: predTypeEqRel :: PredType -> EqRel
+ GhcPlugins: promoteCoercion :: Coercion -> Coercion
+ GhcPlugins: realIdUnfolding :: Id -> Unfolding
+ GhcPlugins: recordSelectorTyCon :: Id -> RecSelParent
+ GhcPlugins: repGetTyVar_maybe :: Type -> Maybe TyVar
+ GhcPlugins: repSplitAppTy_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)
+ GhcPlugins: repSplitAppTys :: HasDebugCallStack => Type -> (Type, [Type])
+ GhcPlugins: repSplitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
+ GhcPlugins: resultIsLevPoly :: Type -> Bool
+ GhcPlugins: sameVis :: ArgFlag -> ArgFlag -> Bool
+ GhcPlugins: seqCo :: Coercion -> ()
+ GhcPlugins: seqOccInfo :: OccInfo -> ()
+ GhcPlugins: seqType :: Type -> ()
+ GhcPlugins: seqTypes :: [Type] -> ()
+ GhcPlugins: setCaseBndrEvald :: StrictnessMark -> Id -> Id
+ GhcPlugins: setCoVarName :: CoVar -> Name -> CoVar
+ GhcPlugins: setCoVarUnique :: CoVar -> Unique -> CoVar
+ GhcPlugins: setIdArity :: Id -> Arity -> Id
+ GhcPlugins: setIdCafInfo :: Id -> CafInfo -> Id
+ GhcPlugins: setIdCallArity :: Id -> Arity -> Id
+ GhcPlugins: setIdDemandInfo :: Id -> Demand -> Id
+ GhcPlugins: setIdInfo :: Id -> IdInfo -> Id
+ GhcPlugins: setIdName :: Id -> Name -> Id
+ GhcPlugins: setIdOccInfo :: Id -> OccInfo -> Id
+ GhcPlugins: setIdOneShotInfo :: Id -> OneShotInfo -> Id
+ GhcPlugins: setIdSpecialisation :: Id -> RuleInfo -> Id
+ GhcPlugins: setIdStrictness :: Id -> StrictSig -> Id
+ GhcPlugins: setIdType :: Id -> Type -> Id
+ GhcPlugins: setIdUnfolding :: Id -> Unfolding -> Id
+ GhcPlugins: setIdUnique :: Id -> Unique -> Id
+ GhcPlugins: setInScope :: Subst -> InScopeSet -> Subst
+ GhcPlugins: setInlineActivation :: Id -> Activation -> Id
+ GhcPlugins: setInlinePragma :: Id -> InlinePragma -> Id
+ GhcPlugins: setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma
+ GhcPlugins: setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma
+ GhcPlugins: setJoinResTy :: Int -> Type -> Type -> Type
+ GhcPlugins: setNameLoc :: Name -> SrcSpan -> Name
+ GhcPlugins: setNameUnique :: Name -> Unique -> Name
+ GhcPlugins: setNominalRole_maybe :: Coercion -> Maybe Coercion
+ GhcPlugins: setOccNameSpace :: NameSpace -> OccName -> OccName
+ GhcPlugins: setOneShotLambda :: Id -> Id
+ GhcPlugins: setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag
+ GhcPlugins: setTvSubstEnv :: TCvSubst -> TvSubstEnv -> TCvSubst
+ GhcPlugins: splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
+ GhcPlugins: splitAppTy :: Type -> (Type, Type)
+ GhcPlugins: splitAppTy_maybe :: Type -> Maybe (Type, Type)
+ GhcPlugins: splitAppTys :: Type -> (Type, [Type])
+ GhcPlugins: splitCastTy_maybe :: Type -> Maybe (Type, Coercion)
+ GhcPlugins: splitCoercionType_maybe :: Type -> Maybe (Type, Type)
+ GhcPlugins: splitForAllCo_maybe :: Coercion -> Maybe (TyVar, Coercion, Coercion)
+ GhcPlugins: splitForAllTy :: Type -> (TyVar, Type)
+ GhcPlugins: splitForAllTyVarBndrs :: Type -> ([TyVarBinder], Type)
+ GhcPlugins: splitForAllTy_maybe :: Type -> Maybe (TyVar, Type)
+ GhcPlugins: splitForAllTys :: Type -> ([TyVar], Type)
+ GhcPlugins: splitFunCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
+ GhcPlugins: splitFunTy :: Type -> (Type, Type)
+ GhcPlugins: splitFunTy_maybe :: Type -> Maybe (Type, Type)
+ GhcPlugins: splitFunTys :: Type -> ([Type], Type)
+ GhcPlugins: splitListTyConApp_maybe :: Type -> Maybe Type
+ GhcPlugins: splitPiTy :: Type -> (TyBinder, Type)
+ GhcPlugins: splitPiTy_maybe :: Type -> Maybe (TyBinder, Type)
+ GhcPlugins: splitPiTys :: Type -> ([TyBinder], Type)
+ GhcPlugins: splitPiTysInvisible :: Type -> ([TyBinder], Type)
+ GhcPlugins: splitTyConApp :: Type -> (TyCon, [Type])
+ GhcPlugins: splitTyConAppCo_maybe :: Coercion -> Maybe (TyCon, [Coercion])
+ GhcPlugins: splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
+ GhcPlugins: splitVisVarsOfType :: Type -> Pair TyCoVarSet
+ GhcPlugins: splitVisVarsOfTypes :: [Type] -> Pair TyCoVarSet
+ GhcPlugins: srcDataName :: NameSpace
+ GhcPlugins: stableNameCmp :: Name -> Name -> Ordering
+ GhcPlugins: startsWithUnderscore :: OccName -> Bool
+ GhcPlugins: stateHackOneShot :: OneShotInfo
+ GhcPlugins: stripCoercionTy :: Type -> Coercion
+ GhcPlugins: strongLoopBreaker :: OccInfo
+ GhcPlugins: substBind :: Subst -> CoreBind -> (Subst, CoreBind)
+ GhcPlugins: substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)
+ GhcPlugins: substBndr :: Subst -> Var -> (Subst, Var)
+ GhcPlugins: substBndrs :: Subst -> [Var] -> (Subst, [Var])
+ GhcPlugins: substCo :: Subst -> Coercion -> Coercion
+ GhcPlugins: substCoUnchecked :: TCvSubst -> Coercion -> Coercion
+ GhcPlugins: substCoVar :: TCvSubst -> CoVar -> Coercion
+ GhcPlugins: substCoVarBndr :: TCvSubst -> CoVar -> (TCvSubst, CoVar)
+ GhcPlugins: substCoVars :: TCvSubst -> [CoVar] -> [Coercion]
+ GhcPlugins: substCoWith :: HasCallStack => [TyVar] -> [Type] -> Coercion -> Coercion
+ GhcPlugins: substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion
+ GhcPlugins: substCos :: HasCallStack => TCvSubst -> [Coercion] -> [Coercion]
+ GhcPlugins: substDVarSet :: Subst -> DVarSet -> DVarSet
+ GhcPlugins: substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr
+ GhcPlugins: substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr
+ GhcPlugins: substForAllCoBndrCallbackLC :: Bool -> (Coercion -> Coercion) -> LiftingContext -> TyVar -> Coercion -> (LiftingContext, TyVar, Coercion)
+ GhcPlugins: substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo
+ GhcPlugins: substIdOcc :: Subst -> Id -> Id
+ GhcPlugins: substInScope :: Subst -> InScopeSet
+ GhcPlugins: substLeftCo :: LiftingContext -> Coercion -> Coercion
+ GhcPlugins: substRecBndrs :: Subst -> [Id] -> (Subst, [Id])
+ GhcPlugins: substRightCo :: LiftingContext -> Coercion -> Coercion
+ GhcPlugins: substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]
+ GhcPlugins: substSpec :: Subst -> Id -> RuleInfo -> RuleInfo
+ GhcPlugins: substTheta :: HasCallStack => TCvSubst -> ThetaType -> ThetaType
+ GhcPlugins: substThetaUnchecked :: TCvSubst -> ThetaType -> ThetaType
+ GhcPlugins: substTickish :: Subst -> Tickish Id -> Tickish Id
+ GhcPlugins: substTy :: Subst -> Type -> Type
+ GhcPlugins: substTyAddInScope :: TCvSubst -> Type -> Type
+ GhcPlugins: substTyUnchecked :: TCvSubst -> Type -> Type
+ GhcPlugins: substTyVar :: TCvSubst -> TyVar -> Type
+ GhcPlugins: substTyVarBndr :: HasCallStack => TCvSubst -> TyVar -> (TCvSubst, TyVar)
+ GhcPlugins: substTyVars :: TCvSubst -> [TyVar] -> [Type]
+ GhcPlugins: substTyWith :: HasCallStack => [TyVar] -> [Type] -> Type -> Type
+ GhcPlugins: substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type
+ GhcPlugins: substTys :: HasCallStack => TCvSubst -> [Type] -> [Type]
+ GhcPlugins: substTysUnchecked :: TCvSubst -> [Type] -> [Type]
+ GhcPlugins: substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]
+ GhcPlugins: substUnfolding :: Subst -> Unfolding -> Unfolding
+ GhcPlugins: substUnfoldingSC :: Subst -> Unfolding -> Unfolding
+ GhcPlugins: succeeded :: SuccessFlag -> Bool
+ GhcPlugins: successIf :: Bool -> SuccessFlag
+ GhcPlugins: sumParens :: SDoc -> SDoc
+ GhcPlugins: swapLiftCoEnv :: LiftCoEnv -> LiftCoEnv
+ GhcPlugins: synTyConResKind :: TyCon -> Kind
+ GhcPlugins: tailCallInfo :: OccInfo -> TailCallInfo
+ GhcPlugins: tcClsName :: NameSpace
+ GhcPlugins: tcName :: NameSpace
+ GhcPlugins: tcRepSplitAppTy_maybe :: Type -> Maybe (Type, Type)
+ GhcPlugins: tcRepSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])
+ GhcPlugins: tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])
+ GhcPlugins: tcView :: Type -> Maybe Type
+ GhcPlugins: tidyCo :: TidyEnv -> Coercion -> Coercion
+ GhcPlugins: tidyCos :: TidyEnv -> [Coercion] -> [Coercion]
+ GhcPlugins: tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv
+ GhcPlugins: tidyKind :: TidyEnv -> Kind -> Kind
+ GhcPlugins: tidyNameOcc :: Name -> OccName -> Name
+ GhcPlugins: tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
+ GhcPlugins: tidyOpenKind :: TidyEnv -> Kind -> (TidyEnv, Kind)
+ GhcPlugins: tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
+ GhcPlugins: tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
+ GhcPlugins: tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)
+ GhcPlugins: tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])
+ GhcPlugins: tidyTopType :: Type -> Type
+ GhcPlugins: tidyTyCoVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
+ GhcPlugins: tidyTyCoVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
+ GhcPlugins: tidyTyVarBinder :: TidyEnv -> TyVarBndr TyVar vis -> (TidyEnv, TyVarBndr TyVar vis)
+ GhcPlugins: tidyTyVarBinders :: TidyEnv -> [TyVarBndr TyVar vis] -> (TidyEnv, [TyVarBndr TyVar vis])
+ GhcPlugins: tidyTyVarOcc :: TidyEnv -> TyVar -> TyVar
+ GhcPlugins: tidyType :: TidyEnv -> Type -> Type
+ GhcPlugins: tidyTypes :: TidyEnv -> [Type] -> [Type]
+ GhcPlugins: toPhantomCo :: Coercion -> Coercion
+ GhcPlugins: topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type)
+ GhcPlugins: topNormaliseTypeX :: NormaliseStepper ev -> (ev -> ev -> ev) -> Type -> Maybe (ev, Type)
+ GhcPlugins: toposortTyVars :: [TyCoVar] -> [TyCoVar]
+ GhcPlugins: transferPolyIdInfo :: Id -> [Var] -> Id -> Id
+ GhcPlugins: treatZeroAsInf :: Int -> IntWithInf
+ GhcPlugins: tupleParens :: TupleSort -> SDoc -> SDoc
+ GhcPlugins: tupleSortBoxity :: TupleSort -> Boxity
+ GhcPlugins: tvName :: NameSpace
+ GhcPlugins: tyBinderType :: TyBinder -> Type
+ GhcPlugins: tyCoFVsBndr :: TyVarBinder -> FV -> FV
+ GhcPlugins: tyCoFVsOfCo :: Coercion -> FV
+ GhcPlugins: tyCoFVsOfCos :: [Coercion] -> FV
+ GhcPlugins: tyCoFVsOfType :: Type -> FV
+ GhcPlugins: tyCoVarsOfCo :: Coercion -> TyCoVarSet
+ GhcPlugins: tyCoVarsOfCoDSet :: Coercion -> DTyCoVarSet
+ GhcPlugins: tyCoVarsOfCos :: [Coercion] -> TyCoVarSet
+ GhcPlugins: tyCoVarsOfType :: Type -> TyCoVarSet
+ GhcPlugins: tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet
+ GhcPlugins: tyCoVarsOfTypeWellScoped :: Type -> [TyVar]
+ GhcPlugins: tyCoVarsOfTypes :: [Type] -> TyCoVarSet
+ GhcPlugins: tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]
+ GhcPlugins: tyConAppArgN :: Int -> Type -> Type
+ GhcPlugins: tyConAppArgs :: Type -> [Type]
+ GhcPlugins: tyConAppArgs_maybe :: Type -> Maybe [Type]
+ GhcPlugins: tyConAppTyCon :: Type -> TyCon
+ GhcPlugins: tyConAppTyConPicky_maybe :: Type -> Maybe TyCon
+ GhcPlugins: tyConAppTyCon_maybe :: Type -> Maybe TyCon
+ GhcPlugins: tyConBindersTyBinders :: [TyConBinder] -> [TyBinder]
+ GhcPlugins: tyConRolesRepresentational :: TyCon -> [Role]
+ GhcPlugins: tyConRolesX :: Role -> TyCon -> [Role]
+ GhcPlugins: tyConsOfType :: Type -> UniqSet TyCon
+ GhcPlugins: tyVarKind :: TyVar -> Kind
+ GhcPlugins: type Alignment = Int
+ GhcPlugins: type Arity = Int
+ GhcPlugins: type CoVar = Id
+ GhcPlugins: type CoercionN = Coercion
+ GhcPlugins: type CoercionP = Coercion
+ GhcPlugins: type CoercionR = Coercion
+ GhcPlugins: type ConTag = Int
+ GhcPlugins: type ConTagZ = Int
+ GhcPlugins: type CvSubstEnv = CoVarEnv Coercion
+ GhcPlugins: type DictId = EvId
+ GhcPlugins: type FastStringEnv a = UniqFM a
+ GhcPlugins: type Id = Var
+ GhcPlugins: type IdSubstEnv = IdEnv CoreExpr
+ GhcPlugins: type InId = Id
+ GhcPlugins: type InVar = Var
+ GhcPlugins: type InsideLam = Bool
+ GhcPlugins: type InterestingCxt = Bool
+ GhcPlugins: type JoinArity = Int
+ GhcPlugins: type JoinId = Id
+ GhcPlugins: type Kind = Type
+ GhcPlugins: type KindOrType = Type
+ GhcPlugins: type LiftCoEnv = VarEnv Coercion
+ GhcPlugins: type NormaliseStepper ev = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult ev
+ GhcPlugins: type OccSet = UniqSet OccName
+ GhcPlugins: type OneBranch = Bool
+ GhcPlugins: type OutId = Id
+ GhcPlugins: type OutVar = Var
+ GhcPlugins: type PhaseNum = Int
+ GhcPlugins: type PredType = Type
+ GhcPlugins: type RepArity = Int
+ GhcPlugins: type RuleName = FastString
+ GhcPlugins: type ThetaType = [PredType]
+ GhcPlugins: type TidyOccEnv = UniqFM Int
+ GhcPlugins: type TvSubstEnv = TyVarEnv Type
+ GhcPlugins: type TyCoVar = Id
+ GhcPlugins: type TyVar = Var
+ GhcPlugins: type TyVarBinder = TyVarBndr TyVar ArgFlag
+ GhcPlugins: typeKind :: HasDebugCallStack => Type -> Kind
+ GhcPlugins: typeOneShot :: Type -> OneShotInfo
+ GhcPlugins: typeSize :: Type -> Int
+ GhcPlugins: unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b
+ GhcPlugins: unionManyOccSets :: [OccSet] -> OccSet
+ GhcPlugins: unionOccSets :: OccSet -> OccSet -> OccSet
+ GhcPlugins: unionTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst
+ GhcPlugins: unitOccEnv :: OccName -> a -> OccEnv a
+ GhcPlugins: unitOccSet :: OccName -> OccSet
+ GhcPlugins: unwrapNewTypeStepper :: NormaliseStepper Coercion
+ GhcPlugins: updOneShotInfo :: Id -> OneShotInfo -> Id
+ GhcPlugins: userTypeError_maybe :: Type -> Maybe Type
+ GhcPlugins: weakLoopBreaker :: OccInfo
+ GhcPlugins: wiredInNameTyThing_maybe :: Name -> Maybe TyThing
+ GhcPlugins: worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo
+ GhcPlugins: zapFragileIdInfo :: Id -> Id
+ GhcPlugins: zapFragileOcc :: OccInfo -> OccInfo
+ GhcPlugins: zapIdDemandInfo :: Id -> Id
+ GhcPlugins: zapIdOccInfo :: Id -> Id
+ GhcPlugins: zapIdStrictness :: Id -> Id
+ GhcPlugins: zapIdTailCallInfo :: Id -> Id
+ GhcPlugins: zapIdUsageEnvInfo :: Id -> Id
+ GhcPlugins: zapIdUsageInfo :: Id -> Id
+ GhcPlugins: zapIdUsedOnceInfo :: Id -> Id
+ GhcPlugins: zapJoinId :: Id -> Id
+ GhcPlugins: zapLamIdInfo :: Id -> Id
+ GhcPlugins: zapLiftingContext :: LiftingContext -> LiftingContext
+ GhcPlugins: zapOccTailCallInfo :: OccInfo -> OccInfo
+ GhcPlugins: zapStableUnfolding :: Id -> Id
+ GhcPlugins: zapSubstEnv :: Subst -> Subst
+ GhcPlugins: zapTCvSubst :: TCvSubst -> TCvSubst
+ GhcPlugins: zipCoEnv :: [CoVar] -> [Coercion] -> CvSubstEnv
+ GhcPlugins: zipTvSubst :: [TyVar] -> [Type] -> TCvSubst
+ GhcPlugins: zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnv
+ Hoopl.Block: [BCat] :: Block n O O -> Block n O O -> Block n O O
+ Hoopl.Block: [BCons] :: n O O -> Block n O O -> Block n O O
+ Hoopl.Block: [BMiddle] :: n O O -> Block n O O
+ Hoopl.Block: [BNil] :: Block n O O
+ Hoopl.Block: [BSnoc] :: Block n O O -> n O O -> Block n O O
+ Hoopl.Block: [BlockCC] :: n C O -> Block n O O -> n O C -> Block n C C
+ Hoopl.Block: [BlockCO] :: n C O -> Block n O O -> Block n C O
+ Hoopl.Block: [BlockOC] :: Block n O O -> n O C -> Block n O C
+ Hoopl.Block: [JustO] :: t -> MaybeO O t
+ Hoopl.Block: [NothingO] :: MaybeO C t
+ Hoopl.Block: blockAppend :: Block n e O -> Block n O x -> Block n e x
+ Hoopl.Block: blockCons :: n O O -> Block n O x -> Block n O x
+ Hoopl.Block: blockFromList :: [n O O] -> Block n O O
+ Hoopl.Block: blockJoin :: n C O -> Block n O O -> n O C -> Block n C C
+ Hoopl.Block: blockJoinHead :: n C O -> Block n O x -> Block n C x
+ Hoopl.Block: blockJoinTail :: Block n e O -> n O C -> Block n e C
+ Hoopl.Block: blockSnoc :: Block n e O -> n O O -> Block n e O
+ Hoopl.Block: blockSplit :: Block n C C -> (n C O, Block n O O, n O C)
+ Hoopl.Block: blockSplitHead :: Block n C x -> (n C O, Block n O x)
+ Hoopl.Block: blockSplitTail :: Block n e C -> (Block n e O, n O C)
+ Hoopl.Block: blockToList :: Block n O O -> [n O O]
+ Hoopl.Block: data Block n e x
+ Hoopl.Block: data C
+ Hoopl.Block: data MaybeO ex t
+ Hoopl.Block: data O
+ Hoopl.Block: emptyBlock :: Block n O O
+ Hoopl.Block: firstNode :: Block n C x -> n C O
+ Hoopl.Block: foldBlockNodesB :: forall n a. (forall e x. n e x -> a -> a) -> (forall e x. Block n e x -> IndexedCO x a a -> IndexedCO e a a)
+ Hoopl.Block: foldBlockNodesB3 :: forall n a b c. (n C O -> b -> c, n O O -> b -> b, n O C -> a -> b) -> (forall e x. Block n e x -> IndexedCO x a b -> IndexedCO e c b)
+ Hoopl.Block: foldBlockNodesF :: forall n a. (forall e x. n e x -> a -> a) -> (forall e x. Block n e x -> IndexedCO e a a -> IndexedCO x a a)
+ Hoopl.Block: instance GHC.Base.Functor (Hoopl.Block.MaybeC ex)
+ Hoopl.Block: instance GHC.Base.Functor (Hoopl.Block.MaybeO ex)
+ Hoopl.Block: isEmptyBlock :: Block n e x -> Bool
+ Hoopl.Block: lastNode :: Block n x C -> n O C
+ Hoopl.Block: mapBlock :: (forall e x. n e x -> n' e x) -> Block n e x -> Block n' e x
+ Hoopl.Block: mapBlock' :: (forall e x. n e x -> n' e x) -> (Block n e x -> Block n' e x)
+ Hoopl.Block: mapBlock3' :: forall n n' e x. (n C O -> n' C O, n O O -> n' O O, n O C -> n' O C) -> Block n e x -> Block n' e x
+ Hoopl.Block: replaceFirstNode :: Block n C x -> n C O -> Block n C x
+ Hoopl.Block: replaceLastNode :: Block n x C -> n O C -> Block n x C
+ Hoopl.Collections: class IsMap map where {
+ Hoopl.Collections: class IsSet set where {
+ Hoopl.Collections: mapDelete :: IsMap map => KeyOf map -> map a -> map a
+ Hoopl.Collections: mapDeleteList :: IsMap map => [KeyOf map] -> map a -> map a
+ Hoopl.Collections: mapDifference :: IsMap map => map a -> map a -> map a
+ Hoopl.Collections: mapElems :: IsMap map => map a -> [a]
+ Hoopl.Collections: mapEmpty :: IsMap map => map a
+ Hoopl.Collections: mapFilter :: IsMap map => (a -> Bool) -> map a -> map a
+ Hoopl.Collections: mapFindWithDefault :: IsMap map => a -> KeyOf map -> map a -> a
+ Hoopl.Collections: mapFold :: IsMap map => (a -> b -> b) -> b -> map a -> b
+ Hoopl.Collections: mapFoldWithKey :: IsMap map => (KeyOf map -> a -> b -> b) -> b -> map a -> b
+ Hoopl.Collections: mapFromList :: IsMap map => [(KeyOf map, a)] -> map a
+ Hoopl.Collections: mapFromListWith :: IsMap map => (a -> a -> a) -> [(KeyOf map, a)] -> map a
+ Hoopl.Collections: mapInsert :: IsMap map => KeyOf map -> a -> map a -> map a
+ Hoopl.Collections: mapInsertList :: IsMap map => [(KeyOf map, a)] -> map a -> map a
+ Hoopl.Collections: mapInsertWith :: IsMap map => (a -> a -> a) -> KeyOf map -> a -> map a -> map a
+ Hoopl.Collections: mapIntersection :: IsMap map => map a -> map a -> map a
+ Hoopl.Collections: mapIsSubmapOf :: (IsMap map, Eq a) => map a -> map a -> Bool
+ Hoopl.Collections: mapKeys :: IsMap map => map a -> [KeyOf map]
+ Hoopl.Collections: mapLookup :: IsMap map => KeyOf map -> map a -> Maybe a
+ Hoopl.Collections: mapMap :: IsMap map => (a -> b) -> map a -> map b
+ Hoopl.Collections: mapMapWithKey :: IsMap map => (KeyOf map -> a -> b) -> map a -> map b
+ Hoopl.Collections: mapMember :: IsMap map => KeyOf map -> map a -> Bool
+ Hoopl.Collections: mapNull :: IsMap map => map a -> Bool
+ Hoopl.Collections: mapSingleton :: IsMap map => KeyOf map -> a -> map a
+ Hoopl.Collections: mapSize :: IsMap map => map a -> Int
+ Hoopl.Collections: mapToList :: IsMap map => map a -> [(KeyOf map, a)]
+ Hoopl.Collections: mapUnion :: IsMap map => map a -> map a -> map a
+ Hoopl.Collections: mapUnionWithKey :: IsMap map => (KeyOf map -> a -> a -> a) -> map a -> map a -> map a
+ Hoopl.Collections: mapUnions :: IsMap map => [map a] -> map a
+ Hoopl.Collections: setDelete :: IsSet set => ElemOf set -> set -> set
+ Hoopl.Collections: setDeleteList :: IsSet set => [ElemOf set] -> set -> set
+ Hoopl.Collections: setDifference :: IsSet set => set -> set -> set
+ Hoopl.Collections: setElems :: IsSet set => set -> [ElemOf set]
+ Hoopl.Collections: setEmpty :: IsSet set => set
+ Hoopl.Collections: setFold :: IsSet set => (ElemOf set -> b -> b) -> b -> set -> b
+ Hoopl.Collections: setFromList :: IsSet set => [ElemOf set] -> set
+ Hoopl.Collections: setInsert :: IsSet set => ElemOf set -> set -> set
+ Hoopl.Collections: setInsertList :: IsSet set => [ElemOf set] -> set -> set
+ Hoopl.Collections: setIntersection :: IsSet set => set -> set -> set
+ Hoopl.Collections: setIsSubsetOf :: IsSet set => set -> set -> Bool
+ Hoopl.Collections: setMember :: IsSet set => ElemOf set -> set -> Bool
+ Hoopl.Collections: setNull :: IsSet set => set -> Bool
+ Hoopl.Collections: setSingleton :: IsSet set => ElemOf set -> set
+ Hoopl.Collections: setSize :: IsSet set => set -> Int
+ Hoopl.Collections: setUnion :: IsSet set => set -> set -> set
+ Hoopl.Collections: setUnions :: IsSet set => [set] -> set
+ Hoopl.Collections: type family KeyOf map;
+ Hoopl.Collections: }
+ Hoopl.Dataflow: foldRewriteNodesBwdOO :: forall f. (CmmNode O O -> f -> UniqSM (Block CmmNode O O, f)) -> Block CmmNode O O -> f -> UniqSM (Block CmmNode O O, f)
+ Hoopl.Dataflow: rewriteCmmBwd :: DataflowLattice f -> RewriteFun f -> CmmGraph -> FactBase f -> UniqSM (CmmGraph, FactBase f)
+ Hoopl.Dataflow: type RewriteFun f = CmmBlock -> FactBase f -> UniqSM (CmmBlock, FactBase f)
+ Hoopl.Graph: [GMany] :: MaybeO e (block n O C) -> Body' block n -> MaybeO x (block n C O) -> Graph' block n e x
+ Hoopl.Graph: [GNil] :: Graph' block n O O
+ Hoopl.Graph: [GUnit] :: block n O O -> Graph' block n O O
+ Hoopl.Graph: addBlock :: NonLocal thing => thing C C -> LabelMap (thing C C) -> LabelMap (thing C C)
+ Hoopl.Graph: bodyList :: Body' block n -> [(Label, block n C C)]
+ Hoopl.Graph: class NonLocal thing
+ Hoopl.Graph: data Graph' block (n :: * -> * -> *) e x
+ Hoopl.Graph: emptyBody :: Body' block n
+ Hoopl.Graph: entryLabel :: NonLocal thing => thing C x -> Label
+ Hoopl.Graph: instance Hoopl.Graph.LabelsPtr Hoopl.Label.Label
+ Hoopl.Graph: instance Hoopl.Graph.LabelsPtr Hoopl.Label.LabelSet
+ Hoopl.Graph: instance Hoopl.Graph.LabelsPtr l => Hoopl.Graph.LabelsPtr [l]
+ Hoopl.Graph: instance Hoopl.Graph.NonLocal n => Hoopl.Graph.LabelsPtr (n e Hoopl.Block.C)
+ Hoopl.Graph: instance Hoopl.Graph.NonLocal n => Hoopl.Graph.NonLocal (Hoopl.Block.Block n)
+ Hoopl.Graph: labelsDefined :: forall block n e x. NonLocal (block n) => Graph' block n e x -> LabelSet
+ Hoopl.Graph: mapGraph :: (forall e x. n e x -> n' e x) -> Graph n e x -> Graph n' e x
+ Hoopl.Graph: mapGraphBlocks :: forall block n block' n' e x. (forall e x. block n e x -> block' n' e x) -> (Graph' block n e x -> Graph' block' n' e x)
+ Hoopl.Graph: postorder_dfs_from :: (NonLocal block, LabelsPtr b) => LabelMap (block C C) -> b -> [block C C]
+ Hoopl.Graph: successors :: NonLocal thing => thing e C -> [Label]
+ Hoopl.Graph: type Body n = LabelMap (Block n C C)
+ Hoopl.Graph: type Graph = Graph' Block
+ Hoopl.Label: data Label
+ Hoopl.Label: data LabelMap v
+ Hoopl.Label: data LabelSet
+ Hoopl.Label: instance Data.Foldable.Foldable Hoopl.Label.LabelMap
+ Hoopl.Label: instance Data.Traversable.Traversable Hoopl.Label.LabelMap
+ Hoopl.Label: instance GHC.Base.Functor Hoopl.Label.LabelMap
+ Hoopl.Label: instance GHC.Classes.Eq Hoopl.Label.Label
+ Hoopl.Label: instance GHC.Classes.Eq Hoopl.Label.LabelSet
+ Hoopl.Label: instance GHC.Classes.Eq v => GHC.Classes.Eq (Hoopl.Label.LabelMap v)
+ Hoopl.Label: instance GHC.Classes.Ord Hoopl.Label.Label
+ Hoopl.Label: instance GHC.Classes.Ord Hoopl.Label.LabelSet
+ Hoopl.Label: instance GHC.Classes.Ord v => GHC.Classes.Ord (Hoopl.Label.LabelMap v)
+ Hoopl.Label: instance GHC.Show.Show Hoopl.Label.Label
+ Hoopl.Label: instance GHC.Show.Show Hoopl.Label.LabelSet
+ Hoopl.Label: instance GHC.Show.Show v => GHC.Show.Show (Hoopl.Label.LabelMap v)
+ Hoopl.Label: instance Hoopl.Collections.IsMap Hoopl.Label.LabelMap
+ Hoopl.Label: instance Hoopl.Collections.IsSet Hoopl.Label.LabelSet
+ Hoopl.Label: instance Outputable.Outputable Hoopl.Label.Label
+ Hoopl.Label: instance Outputable.Outputable Hoopl.Label.LabelSet
+ Hoopl.Label: instance Outputable.Outputable a => Outputable.Outputable (Hoopl.Label.LabelMap a)
+ Hoopl.Label: instance Unique.Uniquable Hoopl.Label.Label
+ Hoopl.Label: lookupFact :: Label -> FactBase f -> Maybe f
+ Hoopl.Label: type FactBase f = LabelMap f
+ Hoopl.Label: uniqueToLbl :: Unique -> Label
+ Hoopl.Unique: data UniqueMap v
+ Hoopl.Unique: data UniqueSet
+ Hoopl.Unique: instance Data.Foldable.Foldable Hoopl.Unique.UniqueMap
+ Hoopl.Unique: instance Data.Traversable.Traversable Hoopl.Unique.UniqueMap
+ Hoopl.Unique: instance GHC.Base.Functor Hoopl.Unique.UniqueMap
+ Hoopl.Unique: instance GHC.Classes.Eq Hoopl.Unique.UniqueSet
+ Hoopl.Unique: instance GHC.Classes.Eq v => GHC.Classes.Eq (Hoopl.Unique.UniqueMap v)
+ Hoopl.Unique: instance GHC.Classes.Ord Hoopl.Unique.UniqueSet
+ Hoopl.Unique: instance GHC.Classes.Ord v => GHC.Classes.Ord (Hoopl.Unique.UniqueMap v)
+ Hoopl.Unique: instance GHC.Show.Show Hoopl.Unique.UniqueSet
+ Hoopl.Unique: instance GHC.Show.Show v => GHC.Show.Show (Hoopl.Unique.UniqueMap v)
+ Hoopl.Unique: instance Hoopl.Collections.IsMap Hoopl.Unique.UniqueMap
+ Hoopl.Unique: instance Hoopl.Collections.IsSet Hoopl.Unique.UniqueSet
+ Hoopl.Unique: intToUnique :: Int -> Unique
+ Hoopl.Unique: type Unique = Int
+ HsBinds: [abs_sig] :: HsBindLR idL idR -> Bool
+ HsBinds: instance (HsExtension.DataId idL, HsExtension.DataId idR) => Data.Data.Data (HsBinds.HsBindLR idL idR)
+ HsBinds: instance (HsExtension.DataId idL, HsExtension.DataId idR) => Data.Data.Data (HsBinds.HsLocalBindsLR idL idR)
+ HsBinds: instance (HsExtension.DataId idL, HsExtension.DataId idR) => Data.Data.Data (HsBinds.HsValBindsLR idL idR)
+ HsBinds: instance (HsExtension.DataId idL, HsExtension.DataId idR) => Data.Data.Data (HsBinds.PatSynBind idL idR)
+ HsBinds: instance (HsExtension.SourceTextX idL, HsExtension.SourceTextX idR, HsExtension.OutputableBndrId idL, HsExtension.OutputableBndrId idR) => Outputable.Outputable (HsBinds.HsBindLR idL idR)
+ HsBinds: instance (HsExtension.SourceTextX idL, HsExtension.SourceTextX idR, HsExtension.OutputableBndrId idL, HsExtension.OutputableBndrId idR) => Outputable.Outputable (HsBinds.HsLocalBindsLR idL idR)
+ HsBinds: instance (HsExtension.SourceTextX idL, HsExtension.SourceTextX idR, HsExtension.OutputableBndrId idL, HsExtension.OutputableBndrId idR) => Outputable.Outputable (HsBinds.HsValBindsLR idL idR)
+ HsBinds: instance (HsExtension.SourceTextX idR, HsExtension.OutputableBndrId idL, HsExtension.OutputableBndrId idR) => Outputable.Outputable (HsBinds.PatSynBind idL idR)
+ HsBinds: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsBinds.HsIPBinds p)
+ HsBinds: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsBinds.IPBind p)
+ HsBinds: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsBinds.Sig pass)
+ HsBinds: instance HsExtension.DataId id => Data.Data.Data (HsBinds.HsIPBinds id)
+ HsBinds: instance HsExtension.DataId id => Data.Data.Data (HsBinds.HsPatSynDir id)
+ HsBinds: instance HsExtension.DataId name => Data.Data.Data (HsBinds.IPBind name)
+ HsBinds: instance HsExtension.DataId p => Data.Data.Data (HsBinds.ABExport p)
+ HsBinds: instance HsExtension.DataId pass => Data.Data.Data (HsBinds.FixitySig pass)
+ HsBinds: instance HsExtension.DataId pass => Data.Data.Data (HsBinds.Sig pass)
+ HsBinds: instance HsExtension.OutputableBndrId p => Outputable.Outputable (HsBinds.ABExport p)
+ HsBinds: instance HsExtension.OutputableBndrId pass => Outputable.Outputable (HsBinds.FixitySig pass)
+ HsBinds: type HsPatSynDetails arg = HsConDetails arg [RecordPatSynField arg]
+ HsDecls: FamEqn :: Located (IdP pass) -> pats -> LexicalFixity -> rhs -> FamEqn pass pats rhs
+ HsDecls: [dfid_eqn] :: DataFamInstDecl pass -> FamInstEqn pass (HsDataDefn pass)
+ HsDecls: [feqn_fixity] :: FamEqn pass pats rhs -> LexicalFixity
+ HsDecls: [feqn_pats] :: FamEqn pass pats rhs -> pats
+ HsDecls: [feqn_rhs] :: FamEqn pass pats rhs -> rhs
+ HsDecls: [feqn_tycon] :: FamEqn pass pats rhs -> Located (IdP pass)
+ HsDecls: data FamEqn pass pats rhs
+ HsDecls: instance (HsExtension.DataId pass, Data.Data.Data pats, Data.Data.Data rhs) => Data.Data.Data (HsDecls.FamEqn pass pats rhs)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.AnnDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.ClsInstDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.ConDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.DataFamInstDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.DefaultDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.DerivDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.FamilyDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.ForeignDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.HsDataDefn pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.HsDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.HsDerivingClause pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.HsGroup pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.InstDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.RuleBndr pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.RuleDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.RuleDecls pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.SpliceDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.TyClDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.TyClGroup pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.TyFamInstDecl pass)
+ HsDecls: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsDecls.VectDecl pass)
+ HsDecls: instance Data.Data.Data pass => Data.Data.Data (HsDecls.AnnProvenance pass)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.ClsInstDecl id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.FamilyDecl id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.HsDataDefn id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.HsDecl id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.HsDerivingClause id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.HsGroup id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.InstDecl id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.SpliceDecl id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.TyClDecl id)
+ HsDecls: instance HsExtension.DataId id => Data.Data.Data (HsDecls.TyClGroup id)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.AnnDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.ConDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.DataFamInstDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.DefaultDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.DerivDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.FamilyInfo pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.FamilyResultSig pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.ForeignDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.InjectivityAnn pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.RoleAnnotDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.RuleBndr pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.RuleDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.RuleDecls pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.TyFamInstDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.VectDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.WarnDecl pass)
+ HsDecls: instance HsExtension.DataId pass => Data.Data.Data (HsDecls.WarnDecls pass)
+ HsDecls: instance Outputable.Outputable (HsDecls.FamilyInfo pass)
+ HsDecls: instance Outputable.OutputableBndr (HsExtension.IdP pass) => Outputable.Outputable (HsDecls.RoleAnnotDecl pass)
+ HsDecls: instance Outputable.OutputableBndr (HsExtension.IdP pass) => Outputable.Outputable (HsDecls.WarnDecl pass)
+ HsDecls: instance Outputable.OutputableBndr (HsExtension.IdP pass) => Outputable.Outputable (HsDecls.WarnDecls pass)
+ HsDecls: newtype DataFamInstDecl pass
+ HsDecls: newtype TyFamInstDecl pass
+ HsDecls: pprFamInstLHS :: (SourceTextX pass, OutputableBndrId pass) => Located (IdP pass) -> HsTyPats pass -> LexicalFixity -> HsContext pass -> Maybe (LHsKind pass) -> SDoc
+ HsDecls: type FamInstEqn pass rhs = HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs) Here, the @pats@ are type patterns (with kind and type bndrs). See Note [Family instance declaration binders]
+ HsDecls: type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs)
+ HsExpr: instance (Data.Data.Data body, HsExtension.DataId id) => Data.Data.Data (HsExpr.GRHS id body)
+ HsExpr: instance (Data.Data.Data body, HsExtension.DataId idL, HsExtension.DataId idR) => Data.Data.Data (HsExpr.StmtLR idL idR body)
+ HsExpr: instance (Data.Data.Data body, HsExtension.DataId p) => Data.Data.Data (HsExpr.GRHSs p body)
+ HsExpr: instance (Data.Data.Data body, HsExtension.DataId p) => Data.Data.Data (HsExpr.Match p body)
+ HsExpr: instance (Data.Data.Data body, HsExtension.DataId p) => Data.Data.Data (HsExpr.MatchGroup p body)
+ HsExpr: instance (HsExtension.DataId idL, HsExtension.DataId idR) => Data.Data.Data (HsExpr.ApplicativeArg idL idR)
+ HsExpr: instance (HsExtension.DataId idL, HsExtension.DataId idR) => Data.Data.Data (HsExpr.ParStmtBlock idL idR)
+ HsExpr: instance (HsExtension.SourceTextX idL, HsExtension.OutputableBndrId idL) => Outputable.Outputable (HsExpr.ParStmtBlock idL idR)
+ HsExpr: instance (HsExtension.SourceTextX idL, HsExtension.SourceTextX idR, HsExtension.OutputableBndrId idL, HsExtension.OutputableBndrId idR, Outputable.Outputable body) => Outputable.Outputable (HsExpr.StmtLR idL idR body)
+ HsExpr: instance (HsExtension.SourceTextX idR, HsExtension.OutputableBndrId idR, Outputable.Outputable body) => Outputable.Outputable (HsExpr.Match idR body)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.ArithSeqInfo p)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.HsBracket p)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.HsCmd p)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.HsCmdTop p)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.HsExpr p)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.HsSplice p)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.HsSplicedThing p)
+ HsExpr: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsExpr.SyntaxExpr p)
+ HsExpr: instance (Outputable.Outputable p, Outputable.Outputable (PlaceHolder.NameOrRdrName p)) => Outputable.Outputable (HsExpr.HsStmtContext p)
+ HsExpr: instance Data.Data.Data id => Data.Data.Data (HsExpr.HsMatchContext id)
+ HsExpr: instance Data.Data.Data id => Data.Data.Data (HsExpr.HsStmtContext id)
+ HsExpr: instance HsExtension.DataId id => Data.Data.Data (HsExpr.ArithSeqInfo id)
+ HsExpr: instance HsExtension.DataId id => Data.Data.Data (HsExpr.HsCmd id)
+ HsExpr: instance HsExtension.DataId id => Data.Data.Data (HsExpr.HsSplice id)
+ HsExpr: instance HsExtension.DataId id => Data.Data.Data (HsExpr.HsSplicedThing id)
+ HsExpr: instance HsExtension.DataId id => Data.Data.Data (HsExpr.HsTupArg id)
+ HsExpr: instance HsExtension.DataId p => Data.Data.Data (HsExpr.HsBracket p)
+ HsExpr: instance HsExtension.DataId p => Data.Data.Data (HsExpr.HsCmdTop p)
+ HsExpr: instance HsExtension.DataId p => Data.Data.Data (HsExpr.HsExpr p)
+ HsExpr: instance HsExtension.DataId p => Data.Data.Data (HsExpr.SyntaxExpr p)
+ HsExtension: Parsed :: Pass
+ HsExtension: Renamed :: Pass
+ HsExtension: Typechecked :: Pass
+ HsExtension: class Convertable a b | a -> b
+ HsExtension: class HasDefault a
+ HsExtension: class HasSourceText a
+ HsExtension: convert :: Convertable a b => a -> b
+ HsExtension: data GhcPass (c :: Pass)
+ HsExtension: data Pass
+ HsExtension: def :: HasDefault a => a
+ HsExtension: getSourceText :: HasSourceText a => a -> SourceText
+ HsExtension: instance Data.Data.Data HsExtension.Pass
+ HsExtension: instance Data.Typeable.Internal.Typeable c => Data.Data.Data (HsExtension.GhcPass c)
+ HsExtension: instance GHC.Classes.Eq (HsExtension.GhcPass c)
+ HsExtension: instance HsExtension.Convertable a a
+ HsExtension: instance HsExtension.HasDefault ()
+ HsExtension: instance HsExtension.HasDefault BasicTypes.SourceText
+ HsExtension: instance HsExtension.HasSourceText BasicTypes.SourceText
+ HsExtension: noSourceText :: HasSourceText a => a
+ HsExtension: setSourceText :: HasSourceText a => SourceText -> a
+ HsExtension: sourceText :: HasSourceText a => String -> a
+ HsExtension: type ConvertIdX a b = (XHsDoublePrim a ~ XHsDoublePrim b, XHsFloatPrim a ~ XHsFloatPrim b, XHsRat a ~ XHsRat b, XHsInteger a ~ XHsInteger b, XHsWord64Prim a ~ XHsWord64Prim b, XHsInt64Prim a ~ XHsInt64Prim b, XHsWordPrim a ~ XHsWordPrim b, XHsIntPrim a ~ XHsIntPrim b, XHsInt a ~ XHsInt b, XHsStringPrim a ~ XHsStringPrim b, XHsString a ~ XHsString b, XHsCharPrim a ~ XHsCharPrim b, XHsChar a ~ XHsChar b)
+ HsExtension: type DataId p = (Data p, ForallX Data p, Data (NameOrRdrName (IdP p)), Data (IdP p), Data (PostRn p (IdP p)), Data (PostRn p (Located Name)), Data (PostRn p Bool), Data (PostRn p Fixity), Data (PostRn p NameSet), Data (PostRn p [Name]), Data (PostTc p (IdP p)), Data (PostTc p Coercion), Data (PostTc p ConLike), Data (PostTc p HsWrapper), Data (PostTc p Type), Data (PostTc p [ConLike]), Data (PostTc p [Type]))
+ HsExtension: type ForallX (c :: * -> Constraint) (x :: *) = (c (XHsChar x), c (XHsCharPrim x), c (XHsString x), c (XHsStringPrim x), c (XHsInt x), c (XHsIntPrim x), c (XHsWordPrim x), c (XHsInt64Prim x), c (XHsWord64Prim x), c (XHsInteger x), c (XHsRat x), c (XHsFloatPrim x), c (XHsDoublePrim x))
+ HsExtension: type GhcPs = GhcPass 'Parsed
+ HsExtension: type GhcRn = GhcPass 'Renamed
+ HsExtension: type GhcTc = GhcPass 'Typechecked
+ HsExtension: type GhcTcId = GhcTc
+ HsExtension: type HasDefaultX x = ForallX HasDefault x
+ HsExtension: type OutputableBndrId id = (OutputableBndr (NameOrRdrName (IdP id)), OutputableBndr (IdP id))
+ HsExtension: type SourceTextX x = (HasSourceText (XHsChar x), HasSourceText (XHsCharPrim x), HasSourceText (XHsString x), HasSourceText (XHsStringPrim x), HasSourceText (XHsIntPrim x), HasSourceText (XHsWordPrim x), HasSourceText (XHsInt64Prim x), HasSourceText (XHsWord64Prim x), HasSourceText (XHsInteger x))
+ HsImpExp: instance (GHC.Classes.Eq name, GHC.Classes.Eq (HsExtension.IdP name)) => GHC.Classes.Eq (HsImpExp.IE name)
+ HsImpExp: instance HsExtension.DataId name => Data.Data.Data (HsImpExp.IE name)
+ HsImpExp: instance HsExtension.DataId name => Data.Data.Data (HsImpExp.ImportDecl name)
+ HsImpExp: instance HsExtension.OutputableBndrId pass => Outputable.Outputable (HsImpExp.IE pass)
+ HsImpExp: instance HsExtension.OutputableBndrId pass => Outputable.Outputable (HsImpExp.ImportDecl pass)
+ HsImpExp: instance Outputable.OutputableBndr name => Outputable.Outputable (HsImpExp.IEWrappedName name)
+ HsImpExp: instance Outputable.OutputableBndr name => Outputable.OutputableBndr (HsImpExp.IEWrappedName name)
+ HsLit: convertLit :: (ConvertIdX a b) => HsLit a -> HsLit b
+ HsLit: instance (HsExtension.SourceTextX p, HsExtension.OutputableBndrId p) => Outputable.Outputable (HsLit.HsOverLit p)
+ HsLit: instance GHC.Classes.Eq (HsLit.HsLit x)
+ HsLit: instance GHC.Classes.Eq (HsLit.HsOverLit p)
+ HsLit: instance GHC.Classes.Ord (HsLit.HsOverLit p)
+ HsLit: instance HsExtension.DataId p => Data.Data.Data (HsLit.HsOverLit p)
+ HsLit: instance HsExtension.DataId x => Data.Data.Data (HsLit.HsLit x)
+ HsLit: instance HsExtension.SourceTextX x => Outputable.Outputable (HsLit.HsLit x)
+ HsLit: isCompoundHsLit :: HsLit x -> Bool
+ HsLit: isCompoundHsOverLit :: HsOverLit x -> Bool
+ HsLit: negateOverLitVal :: OverLitVal -> OverLitVal
+ HsPat: instance (Data.Data.Data id, Data.Data.Data arg) => Data.Data.Data (HsPat.HsRecField' id arg)
+ HsPat: instance (HsExtension.DataId p, Data.Data.Data arg) => Data.Data.Data (HsPat.HsRecFields p arg)
+ HsPat: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsPat.Pat pass)
+ HsPat: instance (Outputable.Outputable p, Outputable.Outputable arg) => Outputable.Outputable (HsPat.HsRecField' p arg)
+ HsPat: instance Data.Foldable.Foldable (HsPat.HsRecFields p)
+ HsPat: instance Data.Traversable.Traversable (HsPat.HsRecFields p)
+ HsPat: instance GHC.Base.Functor (HsPat.HsRecFields p)
+ HsPat: instance HsExtension.DataId p => Data.Data.Data (HsPat.Pat p)
+ HsPat: instance Outputable.Outputable arg => Outputable.Outputable (HsPat.HsRecFields p arg)
+ HsPat: isCompoundPat :: Pat a -> Bool
+ HsPat: parenthesizeCompoundPat :: LPat p -> LPat p
+ HsSyn: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsSyn.HsModule pass)
+ HsSyn: instance HsExtension.DataId name => Data.Data.Data (HsSyn.HsModule name)
+ HsTypes: instance (Data.Data.Data arg, Data.Data.Data rec) => Data.Data.Data (HsTypes.HsConDetails arg rec)
+ HsTypes: instance (HsExtension.DataId pass, Data.Data.Data thing) => Data.Data.Data (HsTypes.HsImplicitBndrs pass thing)
+ HsTypes: instance (HsExtension.DataId pass, Data.Data.Data thing) => Data.Data.Data (HsTypes.HsWildCardBndrs pass thing)
+ HsTypes: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsTypes.ConDeclField pass)
+ HsTypes: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsTypes.HsAppType pass)
+ HsTypes: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsTypes.HsTyVarBndr pass)
+ HsTypes: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsTypes.HsType pass)
+ HsTypes: instance (HsExtension.SourceTextX pass, HsExtension.OutputableBndrId pass) => Outputable.Outputable (HsTypes.LHsQTyVars pass)
+ HsTypes: instance GHC.Classes.Eq (HsExtension.PostRn pass (HsExtension.IdP pass)) => GHC.Classes.Eq (HsTypes.FieldOcc pass)
+ HsTypes: instance GHC.Classes.Ord (HsExtension.PostRn pass (HsExtension.IdP pass)) => GHC.Classes.Ord (HsTypes.FieldOcc pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.AmbiguousFieldOcc pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.ConDeclField pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.FieldOcc pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.HsAppType pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.HsTyVarBndr pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.HsType pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.HsWildCardInfo pass)
+ HsTypes: instance HsExtension.DataId pass => Data.Data.Data (HsTypes.LHsQTyVars pass)
+ HsTypes: instance Outputable.Outputable (HsTypes.AmbiguousFieldOcc pass)
+ HsTypes: instance Outputable.Outputable (HsTypes.FieldOcc pass)
+ HsTypes: instance Outputable.Outputable (HsTypes.HsWildCardInfo pass)
+ HsTypes: instance Outputable.Outputable thing => Outputable.Outputable (HsTypes.HsImplicitBndrs pass thing)
+ HsTypes: instance Outputable.Outputable thing => Outputable.Outputable (HsTypes.HsWildCardBndrs pass thing)
+ HsTypes: instance Outputable.OutputableBndr (HsTypes.AmbiguousFieldOcc pass)
+ HsTypes: isCompoundHsType :: LHsType pass -> Bool
+ HsTypes: parenthesizeCompoundHsType :: LHsType pass -> LHsType pass
+ HsTypes: pprHsType :: (SourceTextX pass, OutputableBndrId pass) => HsType pass -> SDoc
+ HsUtils: isBangedHsBind :: HsBind GhcTc -> Bool
+ HsUtils: mkHsAppTypes :: LHsExpr name -> [LHsWcType name] -> LHsExpr name
+ HscTypes: [mi_hpc_hash] :: ModIface -> !Fingerprint
+ HscTypes: [mi_opt_hash] :: ModIface -> !Fingerprint
+ HscTypes: data ModuleGraph
+ HscTypes: extendMG :: ModuleGraph -> ModSummary -> ModuleGraph
+ HscTypes: isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool
+ HscTypes: mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph
+ HscTypes: mgBootModules :: ModuleGraph -> ModuleSet
+ HscTypes: mgElemModule :: ModuleGraph -> Module -> Bool
+ HscTypes: mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary
+ HscTypes: mgModSummaries :: ModuleGraph -> [ModSummary]
+ HscTypes: mkModuleGraph :: [ModSummary] -> ModuleGraph
+ HscTypes: needsTemplateHaskellOrQQ :: ModuleGraph -> Bool
+ Id: isExitJoinId :: Var -> Bool
+ Id: zapStableUnfolding :: Id -> Id
+ IfaceSyn: [ifConUserTvBinders] :: IfaceConDecl -> [IfaceForAllBndr]
+ IfaceType: IfaceFreeCoVar :: CoVar -> IfaceCoercion
+ IfaceType: IfaceHoleCo :: CoVar -> IfaceCoercion
+ IfaceType: ifForAllBndrName :: IfaceForAllBndr -> IfLclName
+ IfaceType: ifForAllBndrTyVar :: IfaceForAllBndr -> IfaceTvBndr
+ IfaceType: inDomIfaceTySubst :: IfaceTySubst -> IfaceTvBndr -> Bool
+ IfaceType: instance GHC.Base.Semigroup IfaceType.IfaceTcArgs
+ IfaceType: pprIfaceForAllPartMust :: [IfaceForAllBndr] -> [IfacePredType] -> SDoc -> SDoc
+ IfaceType: pprPrecIfaceType :: TyPrec -> IfaceType -> SDoc
+ Inst: tcInstBinder :: Maybe (VarEnv Kind) -> TCvSubst -> TyBinder -> TcM (TCvSubst, TcType)
+ Lexer: ITcolumn_prag :: SourceText -> Token
+ Lexer: [use_pos_prags] :: PState -> Bool
+ ListT: instance Control.Monad.Fail.MonadFail (ListT.ListT m)
+ LlvmCodeGen.CodeGen: instance GHC.Base.Semigroup LlvmCodeGen.CodeGen.LlvmAccum
+ LlvmCodeGen.CodeGen: instance GHC.Classes.Eq LlvmCodeGen.CodeGen.Signage
+ LlvmCodeGen.CodeGen: instance GHC.Show.Show LlvmCodeGen.CodeGen.Signage
+ Module: delModuleSet :: ModuleSet -> Module -> ModuleSet
+ Module: extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet
+ Module: intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
+ Module: minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
+ Module: moduleName :: Module -> ModuleName
+ Module: moduleUnitId :: Module -> UnitId
+ Module: unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
+ Module: unitModuleSet :: Module -> ModuleSet
+ OrdList: instance GHC.Base.Semigroup (OrdList.OrdList a)
+ Outputable: getPprDebug :: (Bool -> SDoc) -> SDoc
+ Outputable: instance Outputable.Outputable GHC.Integer.Type.Integer
+ Outputable: pprInfixOcc :: OutputableBndr a => a -> SDoc
+ Outputable: pprPrefixOcc :: OutputableBndr a => a -> SDoc
+ Outputable: pprTraceException :: ExceptionMonad m => String -> SDoc -> m a -> m a
+ Outputable: whenPprDebug :: SDoc -> SDoc
+ PPC.Instr: HWSYNC :: Instr
+ PPC.Instr: ISYNC :: Instr
+ PPC.Instr: LDR :: Format -> Reg -> AddrMode -> Instr
+ PPC.Instr: NAND :: Reg -> Reg -> Reg -> Instr
+ PPC.Instr: STC :: Format -> Reg -> AddrMode -> Instr
+ Packages: collectArchives :: DynFlags -> PackageConfig -> IO [FilePath]
+ Packages: instance GHC.Base.Semigroup Packages.ModuleOrigin
+ Packages: instance GHC.Base.Semigroup Packages.UnitVisibility
+ Pair: instance (GHC.Base.Semigroup a, GHC.Base.Monoid a) => GHC.Base.Monoid (Pair.Pair a)
+ Pair: instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Pair.Pair a)
+ Plugins: type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()
+ PprCmm: instance Outputable.Outputable (Hoopl.Block.Block CmmNode.CmmNode Hoopl.Block.C Hoopl.Block.C)
+ PprCmm: instance Outputable.Outputable (Hoopl.Block.Block CmmNode.CmmNode Hoopl.Block.C Hoopl.Block.O)
+ PprCmm: instance Outputable.Outputable (Hoopl.Block.Block CmmNode.CmmNode Hoopl.Block.O Hoopl.Block.C)
+ PprCmm: instance Outputable.Outputable (Hoopl.Block.Block CmmNode.CmmNode Hoopl.Block.O Hoopl.Block.O)
+ PprCmm: instance Outputable.Outputable (Hoopl.Graph.Graph CmmNode.CmmNode e x)
+ PprColour: instance GHC.Base.Semigroup PprColour.PprColour
+ PrelInfo: lookupKnownNameInfo :: Name -> SDoc
+ PrelNames: all_RDR :: RdrName
+ PrelNames: dEBUG_TRACE :: Module
+ PrelNames: mkTrTypeKey :: Unique
+ PrelNames: mkTrTypeName :: Name
+ PrelNames: null_RDR :: RdrName
+ PrelNames: readField_RDR :: RdrName
+ PrelNames: readSymField_RDR :: RdrName
+ PrelNames: traceKey :: Unique
+ PrelNames: traceName :: Name
+ PrelNames: typeNatDivTyFamNameKey :: Unique
+ PrelNames: typeNatLogTyFamNameKey :: Unique
+ PrelNames: typeNatModTyFamNameKey :: Unique
+ PrimOp: CompareByteArraysOp :: PrimOp
+ PrimOp: Pdep16Op :: PrimOp
+ PrimOp: Pdep32Op :: PrimOp
+ PrimOp: Pdep64Op :: PrimOp
+ PrimOp: Pdep8Op :: PrimOp
+ PrimOp: PdepOp :: PrimOp
+ PrimOp: Pext16Op :: PrimOp
+ PrimOp: Pext32Op :: PrimOp
+ PrimOp: Pext64Op :: PrimOp
+ PrimOp: Pext8Op :: PrimOp
+ PrimOp: PextOp :: PrimOp
+ PrimOp: isComparisonPrimOp :: PrimOp -> Bool
+ RdrName: isStar :: RdrName -> Bool
+ RdrName: isUniStar :: RdrName -> Bool
+ RnBinds: rnSrcFixityDecl :: HsSigCtxt -> FixitySig GhcPs -> RnM (FixitySig GhcRn)
+ RnEnv: FoundFL :: FieldLabel -> ChildLookupResult
+ RnEnv: FoundName :: Parent -> Name -> ChildLookupResult
+ RnEnv: IncorrectParent :: Name -> Name -> SDoc -> [Name] -> ChildLookupResult
+ RnEnv: NameNotFound :: ChildLookupResult
+ RnEnv: combineChildLookupResult :: [RnM ChildLookupResult] -> RnM ChildLookupResult
+ RnEnv: data ChildLookupResult
+ RnEnv: instance GHC.Base.Monoid RnEnv.DisambigInfo
+ RnEnv: instance GHC.Base.Semigroup RnEnv.DisambigInfo
+ RnEnv: instance Outputable.Outputable RnEnv.ChildLookupResult
+ RnEnv: instance Outputable.Outputable RnEnv.DisambigInfo
+ RnEnv: lookupLocalOccRn :: RdrName -> RnM Name
+ RnEnv: lookupSubBndrOcc_helper :: Bool -> Bool -> Name -> RdrName -> RnM ChildLookupResult
+ RnExpr: instance Outputable.Outputable a => Outputable.Outputable (RnExpr.StmtTree a)
+ RnFixity: addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a
+ RnFixity: lookupFieldFixityRn :: AmbiguousFieldOcc GhcRn -> RnM Fixity
+ RnFixity: lookupFixityRn :: Name -> RnM Fixity
+ RnFixity: lookupFixityRn_help :: Name -> RnM (Bool, Fixity)
+ RnFixity: lookupTyFixityRn :: Located Name -> RnM Fixity
+ RnFixity: type MiniFixityEnv = FastStringEnv (Located Fixity)
+ RnNames: dodgyMsgInsert :: forall p. IdP p -> IE p
+ RnTypes: elemRdr :: Located RdrName -> [Located RdrName] -> Bool
+ RnTypes: extractFilteredRdrTyVarsDups :: LHsType GhcPs -> RnM FreeKiTyVarsWithDups
+ RnTypes: extractHsTyRdrTyVarsDups :: LHsType GhcPs -> RnM FreeKiTyVarsWithDups
+ RnTypes: extractHsTyRdrTyVarsKindVars :: LHsType GhcPs -> RnM [Located RdrName]
+ RnUnbound: WL_Any :: WhereLooking
+ RnUnbound: WL_Global :: WhereLooking
+ RnUnbound: WL_LocalOnly :: WhereLooking
+ RnUnbound: WL_LocalTop :: WhereLooking
+ RnUnbound: data WhereLooking
+ RnUnbound: isUnboundName :: Name -> Bool
+ RnUnbound: mkUnboundName :: OccName -> Name
+ RnUnbound: mkUnboundNameRdr :: RdrName -> Name
+ RnUnbound: perhapsForallMsg :: SDoc
+ RnUnbound: reportUnboundName :: RdrName -> RnM Name
+ RnUnbound: unboundName :: WhereLooking -> RdrName -> RnM Name
+ RnUnbound: unboundNameX :: WhereLooking -> RdrName -> SDoc -> RnM Name
+ RnUnbound: unknownNameSuggestions :: DynFlags -> GlobalRdrEnv -> LocalRdrEnv -> ImportAvails -> RdrName -> SDoc
+ RnUtils: ClassDeclCtx :: (Located RdrName) -> HsDocContext
+ RnUtils: ClassInstanceCtx :: HsDocContext
+ RnUtils: ConDeclCtx :: [Located Name] -> HsDocContext
+ RnUtils: DefaultDeclCtx :: HsDocContext
+ RnUtils: DerivDeclCtx :: HsDocContext
+ RnUtils: ExprWithTySigCtx :: HsDocContext
+ RnUtils: FamPatCtx :: (Located RdrName) -> HsDocContext
+ RnUtils: ForeignDeclCtx :: (Located RdrName) -> HsDocContext
+ RnUtils: GHCiCtx :: HsDocContext
+ RnUtils: GenericCtx :: SDoc -> HsDocContext
+ RnUtils: HsTypeCtx :: HsDocContext
+ RnUtils: PatCtx :: HsDocContext
+ RnUtils: RuleCtx :: FastString -> HsDocContext
+ RnUtils: SpecInstSigCtx :: HsDocContext
+ RnUtils: SpliceTypeCtx :: (LHsType GhcPs) -> HsDocContext
+ RnUtils: TyDataCtx :: (Located RdrName) -> HsDocContext
+ RnUtils: TyFamilyCtx :: (Located RdrName) -> HsDocContext
+ RnUtils: TySynCtx :: (Located RdrName) -> HsDocContext
+ RnUtils: TypBrCtx :: HsDocContext
+ RnUtils: TypeSigCtx :: SDoc -> HsDocContext
+ RnUtils: VectDeclCtx :: (Located RdrName) -> HsDocContext
+ RnUtils: addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
+ RnUtils: addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
+ RnUtils: badQualBndrErr :: RdrName -> SDoc
+ RnUtils: bindLocalNames :: [Name] -> RnM a -> RnM a
+ RnUtils: bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
+ RnUtils: checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
+ RnUtils: checkDupNames :: [Name] -> RnM ()
+ RnUtils: checkDupRdrNames :: [Located RdrName] -> RnM ()
+ RnUtils: checkShadowedRdrNames :: [Located RdrName] -> RnM ()
+ RnUtils: checkTupSize :: Int -> RnM ()
+ RnUtils: data HsDocContext
+ RnUtils: dupNamesErr :: Outputable n => (n -> SrcSpan) -> NonEmpty n -> RnM ()
+ RnUtils: extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
+ RnUtils: inHsDocContext :: HsDocContext -> SDoc
+ RnUtils: mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
+ RnUtils: mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
+ RnUtils: mkFieldEnv :: GlobalRdrEnv -> NameEnv (FieldLabelString, Name)
+ RnUtils: newLocalBndrRn :: Located RdrName -> RnM Name
+ RnUtils: newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
+ RnUtils: pprHsDocContext :: HsDocContext -> SDoc
+ RnUtils: unknownSubordinateErr :: SDoc -> RdrName -> SDoc
+ RnUtils: warnUnusedLocalBinds :: [Name] -> FreeVars -> RnM ()
+ RnUtils: warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
+ RnUtils: warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
+ RnUtils: warnUnusedTypePatterns :: [Name] -> FreeVars -> RnM ()
+ RnUtils: withHsDocContext :: HsDocContext -> SDoc -> SDoc
+ SMRep: roundUpTo :: ByteOff -> ByteOff -> ByteOff
+ SimplEnv: SimplFloats :: LetFloats -> JoinFloats -> InScopeSet -> SimplFloats
+ SimplEnv: [sfInScope] :: SimplFloats -> InScopeSet
+ SimplEnv: [sfJoinFloats] :: SimplFloats -> JoinFloats
+ SimplEnv: [sfLetFloats] :: SimplFloats -> LetFloats
+ SimplEnv: addJoinFloats :: SimplFloats -> JoinFloats -> SimplFloats
+ SimplEnv: addJoinFlts :: JoinFloats -> JoinFloats -> JoinFloats
+ SimplEnv: addLetFloats :: SimplFloats -> LetFloats -> SimplFloats
+ SimplEnv: addLetFlts :: LetFloats -> LetFloats -> LetFloats
+ SimplEnv: data LetFloats
+ SimplEnv: data SimplFloats
+ SimplEnv: emptyLetFloats :: LetFloats
+ SimplEnv: getTopFloatBinds :: SimplFloats -> [CoreBind]
+ SimplEnv: instance Outputable.Outputable SimplEnv.LetFloats
+ SimplEnv: instance Outputable.Outputable SimplEnv.SimplFloats
+ SimplEnv: letFloatBinds :: LetFloats -> [CoreBind]
+ SimplEnv: mapLetFloats :: LetFloats -> ((Id, CoreExpr) -> (Id, CoreExpr)) -> LetFloats
+ SimplEnv: mkFloatBind :: SimplEnv -> OutBind -> (SimplFloats, SimplEnv)
+ SimplEnv: mkRecFloats :: SimplFloats -> SimplFloats
+ SimplEnv: seDynFlags :: SimplEnv -> DynFlags
+ SimplEnv: setInScopeFromE :: SimplEnv -> SimplEnv -> SimplEnv
+ SimplEnv: setInScopeFromF :: SimplEnv -> SimplFloats -> SimplEnv
+ SimplEnv: type JoinFloat = OutBind
+ SimplEnv: unitJoinFloat :: OutBind -> JoinFloats
+ SimplEnv: unitLetFloat :: OutBind -> LetFloats
+ SimplEnv: wrapJoinFloatsX :: SimplFloats -> OutExpr -> (SimplFloats, OutExpr)
+ SimplMonad: newJoinId :: [Var] -> Type -> SimplM Id
+ SimplUtils: [sc_bndrs] :: SimplCont -> [InBndr]
+ SimplUtils: [sc_body] :: SimplCont -> InExpr
+ SimplUtils: [sc_cci] :: SimplCont -> CallCtxt
+ SimplUtils: [sc_fun] :: SimplCont -> ArgInfo
+ SimplUtils: contIsStop :: SimplCont -> Bool
+ SimplUtils: type StaticEnv = SimplEnv
+ SrcLoc: instance (Data.Data.Data l, Data.Data.Data e) => Data.Data.Data (SrcLoc.GenLocated l e)
+ SrcLoc: instance (GHC.Classes.Eq l, GHC.Classes.Eq e) => GHC.Classes.Eq (SrcLoc.GenLocated l e)
+ SrcLoc: instance (GHC.Classes.Ord l, GHC.Classes.Ord e) => GHC.Classes.Ord (SrcLoc.GenLocated l e)
+ StgCmmLayout: FieldOff :: (NonVoid a) -> ByteOff -> FieldOffOrPadding a
+ StgCmmLayout: Padding :: ByteOff -> ByteOff -> FieldOffOrPadding a
+ StgCmmLayout: data FieldOffOrPadding a
+ StgCmmLayout: mkVirtHeapOffsetsWithPadding :: DynFlags -> Bool -> [NonVoid (PrimRep, a)] -> (WordOff, WordOff, [FieldOffOrPadding a])
+ StringBuffer: decodePrevNChars :: Int -> StringBuffer -> String
+ SysTools: expandTopDir :: FilePath -> String -> String
+ SysTools: initLlvmTargets :: Maybe String -> IO LlvmTargets
+ SysTools.BaseDir: expandTopDir :: FilePath -> String -> String
+ SysTools.BaseDir: findTopDir :: Maybe String -> IO String
+ SysTools.ExtraObj: checkLinkInfo :: DynFlags -> [InstalledUnitId] -> FilePath -> IO Bool
+ SysTools.ExtraObj: getCompilerInfo :: DynFlags -> IO CompilerInfo
+ SysTools.ExtraObj: getLinkInfo :: DynFlags -> [InstalledUnitId] -> IO String
+ SysTools.ExtraObj: ghcLinkInfoNoteName :: String
+ SysTools.ExtraObj: ghcLinkInfoSectionName :: String
+ SysTools.ExtraObj: haveRtsOptsFlags :: DynFlags -> Bool
+ SysTools.ExtraObj: mkExtraObj :: DynFlags -> Suffix -> String -> IO FilePath
+ SysTools.ExtraObj: mkExtraObjToLinkIntoBinary :: DynFlags -> IO FilePath
+ SysTools.ExtraObj: mkNoteObjsToLinkIntoBinary :: DynFlags -> [InstalledUnitId] -> IO [FilePath]
+ SysTools.ExtraObj: platformSupportsSavingLinkOpts :: OS -> Bool
+ SysTools.Info: getCompilerInfo :: DynFlags -> IO CompilerInfo
+ SysTools.Info: getCompilerInfo' :: DynFlags -> IO CompilerInfo
+ SysTools.Info: getLinkerInfo :: DynFlags -> IO LinkerInfo
+ SysTools.Info: getLinkerInfo' :: DynFlags -> IO LinkerInfo
+ SysTools.Info: neededLinkArgs :: LinkerInfo -> [Option]
+ SysTools.Process: BuildError :: !SrcLoc -> !SDoc -> BuildMessage
+ SysTools.Process: BuildMsg :: !SDoc -> BuildMessage
+ SysTools.Process: EOF :: BuildMessage
+ SysTools.Process: breakColon :: String -> Maybe (String, String)
+ SysTools.Process: breakIntColon :: String -> Maybe (Int, String)
+ SysTools.Process: builderMainLoop :: DynFlags -> (String -> String) -> FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> IO ExitCode
+ SysTools.Process: c_locale_env :: (String, String)
+ SysTools.Process: data BuildMessage
+ SysTools.Process: getGccEnv :: [Option] -> IO (Maybe [(String, String)])
+ SysTools.Process: handleProc :: String -> String -> IO (ExitCode, r) -> IO r
+ SysTools.Process: linesPlatform :: String -> [String]
+ SysTools.Process: parseError :: String -> Maybe (String, Int, Int, String)
+ SysTools.Process: readCreateProcessWithExitCode' :: CreateProcess -> IO (ExitCode, String)
+ SysTools.Process: readProcessEnvWithExitCode :: String -> [String] -> (String, String) -> IO (ExitCode, String, String)
+ SysTools.Process: readerProc :: Chan BuildMessage -> Handle -> (String -> String) -> IO ()
+ SysTools.Process: replaceVar :: (String, String) -> [(String, String)] -> [(String, String)]
+ SysTools.Process: runSomething :: DynFlags -> String -> String -> [Option] -> IO ()
+ SysTools.Process: runSomethingFiltered :: DynFlags -> (String -> String) -> String -> String -> [Option] -> Maybe FilePath -> Maybe [(String, String)] -> IO ()
+ SysTools.Process: runSomethingResponseFile :: DynFlags -> (String -> String) -> String -> String -> [Option] -> Maybe [(String, String)] -> IO ()
+ SysTools.Process: runSomethingWith :: DynFlags -> String -> String -> [Option] -> ([String] -> IO (ExitCode, a)) -> IO a
+ SysTools.Tasks: askAr :: DynFlags -> Maybe FilePath -> [Option] -> IO String
+ SysTools.Tasks: askLd :: DynFlags -> [Option] -> IO String
+ SysTools.Tasks: figureLlvmVersion :: DynFlags -> IO (Maybe (Int, Int))
+ SysTools.Tasks: isContainedIn :: String -> String -> Bool
+ SysTools.Tasks: runAr :: DynFlags -> Maybe FilePath -> [Option] -> IO ()
+ SysTools.Tasks: runAs :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runCc :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runClang :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runCpp :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runLibtool :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runLink :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runLlvmLlc :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runLlvmOpt :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runMkDLL :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runPp :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runRanlib :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runSplit :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runUnlit :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: runWindres :: DynFlags -> [Option] -> IO ()
+ SysTools.Tasks: touch :: DynFlags -> String -> String -> IO ()
+ THNames: kindQTyConKey :: Unique
+ THNames: kindQTyConName :: Name
+ THNames: labelEIdKey :: Unique
+ THNames: labelEName :: Name
+ THNames: tyVarBndrQTyConKey :: Unique
+ THNames: tyVarBndrQTyConName :: Name
+ TcCanonical: solveCallStack :: CtEvidence -> EvCallStack -> TcS ()
+ TcClassDcl: instDeclCtxt1 :: LHsSigType GhcRn -> SDoc
+ TcClassDcl: instDeclCtxt2 :: Type -> SDoc
+ TcClassDcl: instDeclCtxt3 :: Class -> [Type] -> SDoc
+ TcDerivUtils: DerivEnv :: Maybe OverlapMode -> [TyVar] -> Class -> [Type] -> TyCon -> [Type] -> TyCon -> [Type] -> DerivContext -> Maybe DerivStrategy -> DerivEnv
+ TcDerivUtils: [denv_cls] :: DerivEnv -> Class
+ TcDerivUtils: [denv_cls_tys] :: DerivEnv -> [Type]
+ TcDerivUtils: [denv_mtheta] :: DerivEnv -> DerivContext
+ TcDerivUtils: [denv_overlap_mode] :: DerivEnv -> Maybe OverlapMode
+ TcDerivUtils: [denv_rep_tc] :: DerivEnv -> TyCon
+ TcDerivUtils: [denv_rep_tc_args] :: DerivEnv -> [Type]
+ TcDerivUtils: [denv_strat] :: DerivEnv -> Maybe DerivStrategy
+ TcDerivUtils: [denv_tc] :: DerivEnv -> TyCon
+ TcDerivUtils: [denv_tc_args] :: DerivEnv -> [Type]
+ TcDerivUtils: [denv_tvs] :: DerivEnv -> [TyVar]
+ TcDerivUtils: data DerivEnv
+ TcDerivUtils: instance Outputable.Outputable TcDerivUtils.DerivEnv
+ TcDerivUtils: type DerivM = ReaderT DerivEnv TcRn
+ TcEnv: instance (HsExtension.SourceTextX a, HsExtension.OutputableBndrId a) => Outputable.Outputable (TcEnv.InstInfo a)
+ TcEnv: tcExtendBinderStack :: [TcBinder] -> TcM a -> TcM a
+ TcEnv: tcInitOpenTidyEnv :: [TyCoVar] -> TcM TidyEnv
+ TcEnv: tcInitTidyEnv :: TcM TidyEnv
+ TcEnv: tcLookupIdMaybe :: Name -> TcM (Maybe Id)
+ TcErrors: instance GHC.Base.Semigroup TcErrors.Report
+ TcEvidence: filterEvBindMap :: (EvBind -> Bool) -> EvBindMap -> EvBindMap
+ TcEvidence: isTcReflexiveCo :: TcCoercion -> Bool
+ TcFlatten: unflattenWanteds :: Cts -> Cts -> TcS Cts
+ TcGenDeriv: mkRdrFunBindEC :: Arity -> (LHsExpr GhcPs -> LHsExpr GhcPs) -> Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsBind GhcPs
+ TcGenDeriv: mkRdrFunBindSE :: Arity -> Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsBind GhcPs
+ TcHsSyn: zonkTcEvBinds :: ZonkEnv -> TcEvBinds -> TcM (ZonkEnv, TcEvBinds)
+ TcHsType: AnyDataKind :: DataKindCheck
+ TcHsType: LiftedDataKind :: DataKindCheck
+ TcHsType: LiftedOrVarDataKind :: DataKindCheck
+ TcHsType: checkExpectedKindX :: Maybe (VarEnv Kind) -> SDoc -> TcType -> TcKind -> TcKind -> TcM (TcType, [TcType], TcCoercionN)
+ TcHsType: data DataKindCheck
+ TcHsType: instantiateTyUntilN :: Maybe (VarEnv Kind) -> Int -> TcType -> TcKind -> TcM (TcType, [TcType], TcKind)
+ TcHsType: kcLHsQTyVars :: Name -> TyConFlavour -> Bool -> Bool -> LHsQTyVars GhcRn -> TcM (Kind, r) -> TcM (TcTyCon, r)
+ TcHsType: kcLHsTyVarBndrs :: Bool -> [LHsTyVarBndr GhcRn] -> TcM r -> TcM ([TyVar], r)
+ TcHsType: kindLevelMode :: TcTyMode
+ TcHsType: reportFloatingKvs :: Name -> TyConFlavour -> [TcTyVar] -> [TcTyVar] -> TcM ()
+ TcHsType: tcLHsTypeUnsaturated :: LHsType GhcRn -> TcM (TcType, TcKind)
+ TcHsType: typeLevelMode :: TcTyMode
+ TcMType: zonkCoVar :: CoVar -> TcM CoVar
+ TcMType: zonkSigTyVarPairs :: [(Name, TcTyVar)] -> TcM [(Name, TcTyVar)]
+ TcRnMonad: mkErrTc :: MsgDoc -> TcM ErrMsg
+ TcRnMonad: setTcEvBindsMap :: EvBindsVar -> EvBindMap -> TcM ()
+ TcRnMonad: unlessXOptM :: Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
+ TcRnMonad: warnIfFlag :: WarningFlag -> Bool -> MsgDoc -> TcRn ()
+ TcRnTypes: CIrredCan :: CtEvidence -> Bool -> Ct
+ TcRnTypes: TcTvBndr :: Name -> TyVar -> TcBinder
+ TcRnTypes: [cc_insol] :: Ct -> Bool
+ TcRnTypes: [ic_need_inner] :: Implication -> VarSet
+ TcRnTypes: [ic_need_outer] :: Implication -> VarSet
+ TcRnTypes: [tcg_th_coreplugins] :: TcGblEnv -> TcRef [String]
+ TcRnTypes: [uo_visible] :: CtOrigin -> Bool
+ TcRnTypes: ctEvEvId :: CtEvidence -> EvVar
+ TcRnTypes: data TcBinder
+ TcRnTypes: emptyRoleAnnotEnv :: RoleAnnotEnv
+ TcRnTypes: eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool
+ TcRnTypes: eqCanRewrite :: EqRel -> EqRel -> Bool
+ TcRnTypes: getRoleAnnots :: [Name] -> RoleAnnotEnv -> ([LRoleAnnotDecl GhcRn], RoleAnnotEnv)
+ TcRnTypes: insolubleEqCt :: Ct -> Bool
+ TcRnTypes: insolubleWantedCt :: Ct -> Bool
+ TcRnTypes: instance OccName.HasOccName TcRnTypes.TcBinder
+ TcRnTypes: instance Outputable.Outputable TcRnTypes.Hole
+ TcRnTypes: instance Outputable.Outputable TcRnTypes.TcBinder
+ TcRnTypes: isDroppableCt :: Ct -> Bool
+ TcRnTypes: isVisibleOrigin :: CtOrigin -> Bool
+ TcRnTypes: lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
+ TcRnTypes: mkInsolubleCt :: CtEvidence -> Ct
+ TcRnTypes: mkIrredCt :: CtEvidence -> Ct
+ TcRnTypes: mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv
+ TcRnTypes: newImplication :: Implication
+ TcRnTypes: toInvisibleOrigin :: CtOrigin -> CtOrigin
+ TcRnTypes: type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)
+ TcRnTypes: type TcBinderStack = [TcBinder]
+ TcRnTypes: updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc
+ TcRnTypes: wrapType :: Type -> [TyVar] -> [PredType] -> Type
+ TcRnTypes: wrapTypeWithImplication :: Type -> Implication -> Type
+ TcSMonad: [inert_fsks] :: InertSet -> [(TcTyVar, TcType)]
+ TcSMonad: getTcEvTyCoVars :: EvBindsVar -> TcS TyCoVarSet
+ TcSMonad: setTcEvBindsMap :: EvBindsVar -> EvBindMap -> TcS ()
+ TcSimplify: tcCheckHoleFit :: Cts -> TcSigmaType -> TcSigmaType -> TcM Bool
+ TcSimplify: tcSubsumes :: TcSigmaType -> TcSigmaType -> TcM Bool
+ TcType: FlatSkolTv :: MetaInfo
+ TcType: findDupSigTvs :: [(Name, TcTyVar)] -> [(Name, Name)]
+ TcType: hasIPPred :: PredType -> Bool
+ TcType: instance GHC.Base.Semigroup TcType.CandidatesQTvs
+ TcType: isNextArgVisible :: TcType -> Bool
+ TcType: isNextTyConArgVisible :: TyCon -> [Type] -> Bool
+ TcType: isTyVarHead :: TcTyVar -> TcType -> Bool
+ TcType: mkTyVarNamePairs :: [TyVar] -> [(Name, TyVar)]
+ TcType: pprParendTheta :: ThetaType -> SDoc
+ TcType: tcGetCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)
+ TcType: tcRepGetNumAppTys :: Type -> Arity
+ TcType: tcSplitPiTy_maybe :: Type -> Maybe (TyBinder, Type)
+ TcType: tcTyConVisibilities :: TyCon -> [Bool]
+ TcTypeNats: typeNatDivTyCon :: TyCon
+ TcTypeNats: typeNatLogTyCon :: TyCon
+ TcTypeNats: typeNatModTyCon :: TyCon
+ ToIface: toIfaceCoercionX :: VarSet -> Coercion -> IfaceCoercion
+ TrieMap: instance (TrieMap.TrieMap m, Outputable.Outputable a) => Outputable.Outputable (TrieMap.ListMap m a)
+ TyCon: AbstractTypeFlavour :: TyConFlavour
+ TyCon: BuiltInTypeFlavour :: TyConFlavour
+ TyCon: ClassFlavour :: TyConFlavour
+ TyCon: ClosedTypeFamilyFlavour :: TyConFlavour
+ TyCon: DataFamilyFlavour :: TyConFlavour
+ TyCon: DataTypeFlavour :: TyConFlavour
+ TyCon: NewtypeFlavour :: TyConFlavour
+ TyCon: OpenTypeFamilyFlavour :: TyConFlavour
+ TyCon: PromotedDataConFlavour :: TyConFlavour
+ TyCon: SumFlavour :: TyConFlavour
+ TyCon: TupleFlavour :: Boxity -> TyConFlavour
+ TyCon: TypeSynonymFlavour :: TyConFlavour
+ TyCon: data TyConFlavour
+ TyCon: instance GHC.Classes.Eq TyCon.TyConFlavour
+ TyCon: instance Outputable.Outputable TyCon.TyConFlavour
+ TyCon: primRepSizeB :: DynFlags -> PrimRep -> Int
+ TyCon: tcFlavourCanBeUnsaturated :: TyConFlavour -> Bool
+ TyCon: tcFlavourIsOpen :: TyConFlavour -> Bool
+ TyCon: tyConFamilySizeAtMost :: TyCon -> Int -> Bool
+ TyCon: tyConInjectivityInfo :: TyCon -> Injectivity
+ TyCon: tyConTyVarBinders :: [TyConBinder] -> [TyVarBinder]
+ TyCon: tyConVisibleTyVars :: TyCon -> [TyVar]
+ Type: extendTvSubstBinderAndInScope :: TCvSubst -> TyBinder -> Type -> TCvSubst
+ Type: pprPrecType :: TyPrec -> Type -> SDoc
+ TysWiredIn: coercibleTyConName :: Name
+ UniqDFM: instance GHC.Base.Semigroup (UniqDFM.UniqDFM a)
+ UniqDSet: uniqDSetIntersectUniqSet :: UniqDSet a -> UniqSet b -> UniqDSet a
+ UniqFM: instance GHC.Base.Semigroup (UniqFM.UniqFM a)
+ UniqMap: addListToUniqMap :: Uniquable k => UniqMap k a -> [(k, a)] -> UniqMap k a
+ UniqMap: addListToUniqMap_C :: Uniquable k => (a -> a -> a) -> UniqMap k a -> [(k, a)] -> UniqMap k a
+ UniqMap: addToUniqMap :: Uniquable k => UniqMap k a -> k -> a -> UniqMap k a
+ UniqMap: addToUniqMap_Acc :: Uniquable k => (b -> a -> a) -> (b -> a) -> UniqMap k a -> k -> b -> UniqMap k a
+ UniqMap: addToUniqMap_C :: Uniquable k => (a -> a -> a) -> UniqMap k a -> k -> a -> UniqMap k a
+ UniqMap: adjustUniqMap :: Uniquable k => (a -> a) -> UniqMap k a -> k -> UniqMap k a
+ UniqMap: allUniqMap :: (a -> Bool) -> UniqMap k a -> Bool
+ UniqMap: alterUniqMap :: Uniquable k => (Maybe a -> Maybe a) -> UniqMap k a -> k -> UniqMap k a
+ UniqMap: anyUniqMap :: (a -> Bool) -> UniqMap k a -> Bool
+ UniqMap: data UniqMap k a
+ UniqMap: delFromUniqMap :: Uniquable k => UniqMap k a -> k -> UniqMap k a
+ UniqMap: delListFromUniqMap :: Uniquable k => UniqMap k a -> [k] -> UniqMap k a
+ UniqMap: disjointUniqMap :: UniqMap k a -> UniqMap k b -> Bool
+ UniqMap: elemUniqMap :: Uniquable k => k -> UniqMap k a -> Bool
+ UniqMap: emptyUniqMap :: UniqMap k a
+ UniqMap: filterUniqMap :: (a -> Bool) -> UniqMap k a -> UniqMap k a
+ UniqMap: instance (Data.Data.Data k, Data.Data.Data a) => Data.Data.Data (UniqMap.UniqMap k a)
+ UniqMap: instance (GHC.Classes.Eq k, GHC.Classes.Eq a) => GHC.Classes.Eq (UniqMap.UniqMap k a)
+ UniqMap: instance (Outputable.Outputable k, Outputable.Outputable a) => Outputable.Outputable (UniqMap.UniqMap k a)
+ UniqMap: instance GHC.Base.Functor (UniqMap.UniqMap k)
+ UniqMap: instance GHC.Base.Monoid (UniqMap.UniqMap k a)
+ UniqMap: instance GHC.Base.Semigroup (UniqMap.UniqMap k a)
+ UniqMap: intersectUniqMap :: UniqMap k a -> UniqMap k b -> UniqMap k a
+ UniqMap: isNullUniqMap :: UniqMap k a -> Bool
+ UniqMap: listToUniqMap :: Uniquable k => [(k, a)] -> UniqMap k a
+ UniqMap: listToUniqMap_C :: Uniquable k => (a -> a -> a) -> [(k, a)] -> UniqMap k a
+ UniqMap: lookupUniqMap :: Uniquable k => UniqMap k a -> k -> Maybe a
+ UniqMap: lookupWithDefaultUniqMap :: Uniquable k => UniqMap k a -> a -> k -> a
+ UniqMap: mapUniqMap :: (a -> b) -> UniqMap k a -> UniqMap k b
+ UniqMap: minusUniqMap :: UniqMap k a -> UniqMap k b -> UniqMap k a
+ UniqMap: partitionUniqMap :: (a -> Bool) -> UniqMap k a -> (UniqMap k a, UniqMap k a)
+ UniqMap: plusMaybeUniqMap_C :: (a -> a -> Maybe a) -> UniqMap k a -> UniqMap k a -> UniqMap k a
+ UniqMap: plusUniqMap :: UniqMap k a -> UniqMap k a -> UniqMap k a
+ UniqMap: plusUniqMapList :: [UniqMap k a] -> UniqMap k a
+ UniqMap: plusUniqMap_C :: (a -> a -> a) -> UniqMap k a -> UniqMap k a -> UniqMap k a
+ UniqMap: sizeUniqMap :: UniqMap k a -> Int
+ UniqMap: unitUniqMap :: Uniquable k => k -> a -> UniqMap k a
+ UniqSet: instance GHC.Base.Semigroup (UniqSet.UniqSet a)
+ Unique: initExitJoinUnique :: Unique
+ Util: lengthAtMost :: [a] -> Int -> Bool
+ Util: lengthIsNot :: [a] -> Int -> Bool
+ Util: lengthLessThan :: [a] -> Int -> Bool
+ Util: ltLength :: [a] -> [b] -> Bool
+ Util: neLength :: [a] -> [b] -> Bool
+ Util: readHexRational :: String -> Rational
+ Var: instance (Data.Data.Data tyvar, Data.Data.Data argf) => Data.Data.Data (Var.TyVarBndr tyvar argf)
+ Var: mkTyVarBinder :: ArgFlag -> Var -> TyVarBinder
+ Var: mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder]
+ VarEnv: filterDVarEnv :: (a -> Bool) -> DVarEnv a -> DVarEnv a
+ VarSet: dVarSetIntersectVarSet :: DVarSet -> VarSet -> DVarSet
+ VarSet: mapVarSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b
+ X86.Instr: PDEP :: Format -> Operand -> Operand -> Reg -> Instr
+ X86.Instr: PEXT :: Format -> Operand -> Operand -> Reg -> Instr
- AsmCodeGen: NcgImpl :: (RawCmmDecl -> NatM [NatCmmDecl statics instr]) -> (instr -> Maybe (NatCmmDecl statics instr)) -> (jumpDest -> Maybe BlockId) -> (instr -> Maybe jumpDest) -> ((BlockId -> Maybe jumpDest) -> statics -> statics) -> ((BlockId -> Maybe jumpDest) -> instr -> instr) -> (NatCmmDecl statics instr -> SDoc) -> Int -> [RealReg] -> ([NatCmmDecl statics instr] -> [NatCmmDecl statics instr]) -> ([NatCmmDecl statics instr] -> [NatCmmDecl statics instr]) -> (Int -> NatCmmDecl statics instr -> UniqSM (NatCmmDecl statics instr)) -> (LabelMap CmmStatics -> [NatBasicBlock instr] -> [NatBasicBlock instr]) -> ([instr] -> [UnwindPoint]) -> NcgImpl statics instr jumpDest
+ AsmCodeGen: NcgImpl :: RawCmmDecl -> NatM [NatCmmDecl statics instr] -> instr -> Maybe (NatCmmDecl statics instr) -> jumpDest -> Maybe BlockId -> instr -> Maybe jumpDest -> (BlockId -> Maybe jumpDest) -> statics -> statics -> (BlockId -> Maybe jumpDest) -> instr -> instr -> NatCmmDecl statics instr -> SDoc -> Int -> [RealReg] -> [NatCmmDecl statics instr] -> [NatCmmDecl statics instr] -> [NatCmmDecl statics instr] -> [NatCmmDecl statics instr] -> Int -> NatCmmDecl statics instr -> UniqSM (NatCmmDecl statics instr) -> LabelMap CmmStatics -> [NatBasicBlock instr] -> [NatBasicBlock instr] -> [instr] -> [UnwindPoint] -> NcgImpl statics instr jumpDest
- BasicTypes: FL :: String -> Rational -> FractionalLit
+ BasicTypes: FL :: SourceText -> Bool -> Rational -> FractionalLit
- BasicTypes: [fl_text] :: FractionalLit -> String
+ BasicTypes: [fl_text] :: FractionalLit -> SourceText
- BasicTypes: integralFractionalLit :: Integer -> FractionalLit
+ BasicTypes: integralFractionalLit :: Bool -> Integer -> FractionalLit
- Binary: UserData :: (BinHandle -> IO Name) -> (BinHandle -> IO FastString) -> (BinHandle -> Name -> IO ()) -> (BinHandle -> Name -> IO ()) -> (BinHandle -> FastString -> IO ()) -> UserData
+ Binary: UserData :: BinHandle -> IO Name -> BinHandle -> IO FastString -> BinHandle -> Name -> IO () -> BinHandle -> Name -> IO () -> BinHandle -> FastString -> IO () -> UserData
- BkpSyn: DeclD :: HsDeclType -> (Located ModuleName) -> (Maybe (Located (HsModule RdrName))) -> HsUnitDecl n
+ BkpSyn: DeclD :: HsDeclType -> (Located ModuleName) -> (Maybe (Located (HsModule GhcPs))) -> HsUnitDecl n
- BuildTyCl: buildDataCon :: FamInstEnvs -> Name -> Bool -> TyConRepName -> [HsSrcBang] -> Maybe [HsImplBang] -> [FieldLabel] -> [TyVarBinder] -> [TyVarBinder] -> [EqSpec] -> ThetaType -> [Type] -> Type -> TyCon -> TcRnIf m n DataCon
+ BuildTyCl: buildDataCon :: FamInstEnvs -> Name -> Bool -> TyConRepName -> [HsSrcBang] -> Maybe [HsImplBang] -> [FieldLabel] -> [TyVar] -> [TyVar] -> [TyVarBinder] -> [EqSpec] -> ThetaType -> [Type] -> Type -> TyCon -> TcRnIf m n DataCon
- ByteCodeAsm: data SizedSeq a :: * -> *
+ ByteCodeAsm: data SizedSeq a
- ByteCodeTypes: UnlinkedBCO :: !Name -> {-# UNPACK #-} !Int -> !(UArray Int Word16) -> !(UArray Int Word) -> !(SizedSeq BCONPtr) -> !(SizedSeq BCOPtr) -> UnlinkedBCO
+ ByteCodeTypes: UnlinkedBCO :: !Name -> {-# UNPACK #-} !Int -> !(UArray Int Word16) -> !(UArray Int Word64) -> !(SizedSeq BCONPtr) -> !(SizedSeq BCOPtr) -> UnlinkedBCO
- ByteCodeTypes: [unlinkedBCOBitmap] :: UnlinkedBCO -> !(UArray Int Word)
+ ByteCodeTypes: [unlinkedBCOBitmap] :: UnlinkedBCO -> !(UArray Int Word64)
- Check: checkMatches :: DynFlags -> DsMatchContext -> [Id] -> [LMatch Id (LHsExpr Id)] -> DsM ()
+ Check: checkMatches :: DynFlags -> DsMatchContext -> [Id] -> [LMatch GhcTc (LHsExpr GhcTc)] -> DsM ()
- Check: checkSingle :: DynFlags -> DsMatchContext -> Id -> Pat Id -> DsM ()
+ Check: checkSingle :: DynFlags -> DsMatchContext -> Id -> Pat GhcTc -> DsM ()
- Check: genCaseTmCs1 :: Maybe (LHsExpr Id) -> [Id] -> Bag SimpleEq
+ Check: genCaseTmCs1 :: Maybe (LHsExpr GhcTc) -> [Id] -> Bag SimpleEq
- Check: genCaseTmCs2 :: Maybe (LHsExpr Id) -> [Pat Id] -> [Id] -> DsM (Bag SimpleEq)
+ Check: genCaseTmCs2 :: Maybe (LHsExpr GhcTc) -> [Pat GhcTc] -> [Id] -> DsM (Bag SimpleEq)
- CmdLineParser: CmdLineP :: (s -> (a, s)) -> CmdLineP s a
+ CmdLineParser: CmdLineP :: s -> (a, s) -> CmdLineP s a
- CmdLineParser: processArgs :: Monad m => [Flag m] -> [Located String] -> m ([Located String], [Located String], [Located String])
+ CmdLineParser: processArgs :: Monad m => [Flag m] -> [Located String] -> m ([Located String], [Err], [Warn])
- Cmm: Constr :: ConstrTag -> ConstrDescription -> ClosureTypeInfo
+ Cmm: Constr :: ConTagZ -> ConstrDescription -> ClosureTypeInfo
- CmmMonad: PD :: (DynFlags -> PState -> ParseResult a) -> PD a
+ CmmMonad: PD :: DynFlags -> PState -> ParseResult a -> PD a
- CoAxiom: BuiltInSynFamily :: ([Type] -> Maybe (CoAxiomRule, [Type], Type)) -> ([Type] -> Type -> [TypeEqn]) -> ([Type] -> Type -> [Type] -> Type -> [TypeEqn]) -> BuiltInSynFamily
+ CoAxiom: BuiltInSynFamily :: [Type] -> Maybe (CoAxiomRule, [Type], Type) -> [Type] -> Type -> [TypeEqn] -> [Type] -> Type -> [Type] -> Type -> [TypeEqn] -> BuiltInSynFamily
- CoAxiom: CoAxiomRule :: FastString -> [Role] -> Role -> ([TypeEqn] -> Maybe TypeEqn) -> CoAxiomRule
+ CoAxiom: CoAxiomRule :: FastString -> [Role] -> Role -> [TypeEqn] -> Maybe TypeEqn -> CoAxiomRule
- Coercion: liftCoSubst :: Role -> LiftingContext -> Type -> Coercion
+ Coercion: liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion
- Coercion: mkHoleCo :: CoercionHole -> Role -> Type -> Type -> Coercion
+ Coercion: mkHoleCo :: CoercionHole -> Coercion
- Convert: convertToHsDecls :: SrcSpan -> [Dec] -> Either MsgDoc [LHsDecl RdrName]
+ Convert: convertToHsDecls :: SrcSpan -> [Dec] -> Either MsgDoc [LHsDecl GhcPs]
- Convert: convertToHsExpr :: SrcSpan -> Exp -> Either MsgDoc (LHsExpr RdrName)
+ Convert: convertToHsExpr :: SrcSpan -> Exp -> Either MsgDoc (LHsExpr GhcPs)
- Convert: convertToHsType :: SrcSpan -> Type -> Either MsgDoc (LHsType RdrName)
+ Convert: convertToHsType :: SrcSpan -> Type -> Either MsgDoc (LHsType GhcPs)
- Convert: convertToPat :: SrcSpan -> Pat -> Either MsgDoc (LPat RdrName)
+ Convert: convertToPat :: SrcSpan -> Pat -> Either MsgDoc (LPat GhcPs)
- CoreArity: findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> Arity
+ CoreArity: findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> (Arity, Bool)
- CoreMonad: CoreDoSimplify :: Int -> SimplifierMode -> CoreToDo
+ CoreMonad: CoreDoSimplify :: Int -> SimplMode -> CoreToDo
- CoreMonad: SimplMode :: [String] -> CompilerPhase -> Bool -> Bool -> Bool -> Bool -> SimplifierMode
+ CoreMonad: SimplMode :: [String] -> CompilerPhase -> DynFlags -> Bool -> Bool -> Bool -> Bool -> SimplMode
- CoreMonad: [sm_case_case] :: SimplifierMode -> Bool
+ CoreMonad: [sm_case_case] :: SimplMode -> Bool
- CoreMonad: [sm_eta_expand] :: SimplifierMode -> Bool
+ CoreMonad: [sm_eta_expand] :: SimplMode -> Bool
- CoreMonad: [sm_inline] :: SimplifierMode -> Bool
+ CoreMonad: [sm_inline] :: SimplMode -> Bool
- CoreMonad: [sm_names] :: SimplifierMode -> [String]
+ CoreMonad: [sm_names] :: SimplMode -> [String]
- CoreMonad: [sm_phase] :: SimplifierMode -> CompilerPhase
+ CoreMonad: [sm_phase] :: SimplMode -> CompilerPhase
- CoreMonad: [sm_rules] :: SimplifierMode -> Bool
+ CoreMonad: [sm_rules] :: SimplMode -> Bool
- CoreMonad: liftIO :: MonadIO m => forall a. () => IO a -> m a
+ CoreMonad: liftIO :: MonadIO m => IO a -> m a
- CorePrep: corePrepPgm :: HscEnv -> Module -> ModLocation -> CoreProgram -> [TyCon] -> IO CoreProgram
+ CorePrep: corePrepPgm :: HscEnv -> Module -> ModLocation -> CoreProgram -> [TyCon] -> IO (CoreProgram, Set CostCentre)
- CoreStats: CS :: Int -> Int -> Int -> Int -> Int -> CoreStats
+ CoreStats: CS :: !Int -> !Int -> !Int -> !Int -> !Int -> CoreStats
- CoreStats: [cs_co] :: CoreStats -> Int
+ CoreStats: [cs_co] :: CoreStats -> !Int
- CoreStats: [cs_jb] :: CoreStats -> Int
+ CoreStats: [cs_jb] :: CoreStats -> !Int
- CoreStats: [cs_tm] :: CoreStats -> Int
+ CoreStats: [cs_tm] :: CoreStats -> !Int
- CoreStats: [cs_ty] :: CoreStats -> Int
+ CoreStats: [cs_ty] :: CoreStats -> !Int
- CoreStats: [cs_vb] :: CoreStats -> Int
+ CoreStats: [cs_vb] :: CoreStats -> !Int
- CoreToStg: coreToStg :: DynFlags -> Module -> CoreProgram -> [StgTopBinding]
+ CoreToStg: coreToStg :: DynFlags -> Module -> CoreProgram -> ([StgTopBinding], CollectedCCs)
- CostCentre: type CollectedCCs = ([CostCentre], [CostCentre], [CostCentreStack])
+ CostCentre: type CollectedCCs = ([CostCentre], [CostCentreStack])
- Coverage: addTicksToBinds :: HscEnv -> Module -> ModLocation -> NameSet -> [TyCon] -> LHsBinds Id -> IO (LHsBinds Id, HpcInfo, Maybe ModBreaks)
+ Coverage: addTicksToBinds :: HscEnv -> Module -> ModLocation -> NameSet -> [TyCon] -> LHsBinds GhcTc -> IO (LHsBinds GhcTc, HpcInfo, Maybe ModBreaks)
- DataCon: filterEqSpec :: [EqSpec] -> [TyVarBinder] -> [TyVarBinder]
+ DataCon: filterEqSpec :: [EqSpec] -> [TyVar] -> [TyVar]
- DataCon: mkDataCon :: Name -> Bool -> TyConRepName -> [HsSrcBang] -> [FieldLabel] -> [TyVarBinder] -> [TyVarBinder] -> [EqSpec] -> ThetaType -> [Type] -> Type -> RuntimeRepInfo -> TyCon -> ThetaType -> Id -> DataConRep -> DataCon
+ DataCon: mkDataCon :: Name -> Bool -> TyConRepName -> [HsSrcBang] -> [FieldLabel] -> [TyVar] -> [TyVar] -> [TyVarBinder] -> [EqSpec] -> ThetaType -> [Type] -> Type -> RuntimeRepInfo -> TyCon -> ThetaType -> Id -> DataConRep -> DataCon
- Desugar: deSugarExpr :: HscEnv -> LHsExpr Id -> IO (Messages, Maybe CoreExpr)
+ Desugar: deSugarExpr :: HscEnv -> LHsExpr GhcTc -> IO (Messages, Maybe CoreExpr)
- Digraph: data SCC vertex :: * -> *
+ Digraph: data SCC vertex
- DriverPipeline: P :: (PipeEnv -> PipeState -> IO (PipeState, a)) -> CompPipeline a
+ DriverPipeline: P :: PipeEnv -> PipeState -> IO (PipeState, a) -> CompPipeline a
- DsArrows: dsProcExpr :: LPat Id -> LHsCmdTop Id -> DsM CoreExpr
+ DsArrows: dsProcExpr :: LPat GhcTc -> LHsCmdTop GhcTc -> DsM CoreExpr
- DsBinds: dsLHsBinds :: LHsBinds Id -> DsM ([Id], [(Id, CoreExpr)])
+ DsBinds: dsLHsBinds :: LHsBinds GhcTc -> DsM ([Id], [(Id, CoreExpr)])
- DsBinds: dsTopLHsBinds :: LHsBinds Id -> DsM (OrdList (Id, CoreExpr))
+ DsBinds: dsTopLHsBinds :: LHsBinds GhcTc -> DsM (OrdList (Id, CoreExpr))
- DsExpr: dsExpr :: HsExpr Id -> DsM CoreExpr
+ DsExpr: dsExpr :: HsExpr GhcTc -> DsM CoreExpr
- DsExpr: dsLExpr :: LHsExpr Id -> DsM CoreExpr
+ DsExpr: dsLExpr :: LHsExpr GhcTc -> DsM CoreExpr
- DsExpr: dsLExprNoLP :: LHsExpr Id -> DsM CoreExpr
+ DsExpr: dsLExprNoLP :: LHsExpr GhcTc -> DsM CoreExpr
- DsExpr: dsLit :: HsLit -> DsM CoreExpr
+ DsExpr: dsLit :: HsLit GhcRn -> DsM CoreExpr
- DsExpr: dsLocalBinds :: LHsLocalBinds Id -> CoreExpr -> DsM CoreExpr
+ DsExpr: dsLocalBinds :: LHsLocalBinds GhcTc -> CoreExpr -> DsM CoreExpr
- DsExpr: dsSyntaxExpr :: SyntaxExpr Id -> [CoreExpr] -> DsM CoreExpr
+ DsExpr: dsSyntaxExpr :: SyntaxExpr GhcTc -> [CoreExpr] -> DsM CoreExpr
- DsExpr: dsValBinds :: HsValBinds Id -> CoreExpr -> DsM CoreExpr
+ DsExpr: dsValBinds :: HsValBinds GhcTc -> CoreExpr -> DsM CoreExpr
- DsForeign: dsForeigns :: [LForeignDecl Id] -> DsM (ForeignStubs, OrdList Binding)
+ DsForeign: dsForeigns :: [LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList Binding)
- DsGRHSs: dsGRHS :: HsMatchContext Name -> Type -> LGRHS Id (LHsExpr Id) -> DsM MatchResult
+ DsGRHSs: dsGRHS :: HsMatchContext Name -> Type -> LGRHS GhcTc (LHsExpr GhcTc) -> DsM MatchResult
- DsGRHSs: dsGRHSs :: HsMatchContext Name -> [Pat Id] -> GRHSs Id (LHsExpr Id) -> Type -> DsM MatchResult
+ DsGRHSs: dsGRHSs :: HsMatchContext Name -> GRHSs GhcTc (LHsExpr GhcTc) -> Type -> DsM MatchResult
- DsGRHSs: dsGuarded :: GRHSs Id (LHsExpr Id) -> Type -> DsM CoreExpr
+ DsGRHSs: dsGuarded :: GRHSs GhcTc (LHsExpr GhcTc) -> Type -> DsM CoreExpr
- DsGRHSs: isTrueLHsExpr :: LHsExpr Id -> Maybe (CoreExpr -> DsM CoreExpr)
+ DsGRHSs: isTrueLHsExpr :: LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
- DsListComp: dsListComp :: [ExprLStmt Id] -> Type -> DsM CoreExpr
+ DsListComp: dsListComp :: [ExprLStmt GhcTc] -> Type -> DsM CoreExpr
- DsListComp: dsMonadComp :: [ExprLStmt Id] -> DsM CoreExpr
+ DsListComp: dsMonadComp :: [ExprLStmt GhcTc] -> DsM CoreExpr
- DsListComp: dsPArrComp :: [ExprStmt Id] -> DsM CoreExpr
+ DsListComp: dsPArrComp :: [ExprStmt GhcTc] -> DsM CoreExpr
- DsMeta: dsBracket :: HsBracket Name -> [PendingTcSplice] -> DsM CoreExpr
+ DsMeta: dsBracket :: HsBracket GhcRn -> [PendingTcSplice] -> DsM CoreExpr
- DsMonad: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ DsMonad: (<$>) :: Functor f => a -> b -> f a -> f b
- DsMonad: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ DsMonad: (<*>) :: Applicative f => f a -> b -> f a -> f b
- DsMonad: DsSplice :: (HsExpr Id) -> DsMetaVal
+ DsMonad: DsSplice :: (HsExpr GhcTc) -> DsMetaVal
- DsMonad: EqnInfo :: [Pat Id] -> MatchResult -> EquationInfo
+ DsMonad: EqnInfo :: [Pat GhcTc] -> MatchResult -> EquationInfo
- DsMonad: [eqn_pats] :: EquationInfo -> [Pat Id]
+ DsMonad: [eqn_pats] :: EquationInfo -> [Pat GhcTc]
- DsMonad: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
+ DsMonad: mapAndUnzipM :: Applicative m => a -> m (b, c) -> [a] -> m ([b], [c])
- DsMonad: mapM :: Traversable t => forall (m :: * -> *) a b. Monad m => (a -> m b) -> t a -> m t b
+ DsMonad: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
- DsUtils: EqnInfo :: [Pat Id] -> MatchResult -> EquationInfo
+ DsUtils: EqnInfo :: [Pat GhcTc] -> MatchResult -> EquationInfo
- DsUtils: [eqn_pats] :: EquationInfo -> [Pat Id]
+ DsUtils: [eqn_pats] :: EquationInfo -> [Pat GhcTc]
- DsUtils: firstPat :: EquationInfo -> Pat Id
+ DsUtils: firstPat :: EquationInfo -> Pat GhcTc
- DsUtils: mkBigLHsPatTupId :: [LPat Id] -> LPat Id
+ DsUtils: mkBigLHsPatTupId :: [LPat GhcTc] -> LPat GhcTc
- DsUtils: mkBigLHsTupId :: [LHsExpr Id] -> LHsExpr Id
+ DsUtils: mkBigLHsTupId :: [LHsExpr GhcTc] -> LHsExpr GhcTc
- DsUtils: mkBigLHsVarPatTupId :: [Id] -> LPat Id
+ DsUtils: mkBigLHsVarPatTupId :: [Id] -> LPat GhcTc
- DsUtils: mkBigLHsVarTupId :: [Id] -> LHsExpr Id
+ DsUtils: mkBigLHsVarTupId :: [Id] -> LHsExpr GhcTc
- DsUtils: mkLHsPatTup :: [LPat Id] -> LPat Id
+ DsUtils: mkLHsPatTup :: [LPat GhcTc] -> LPat GhcTc
- DsUtils: mkLHsVarPatTup :: [Id] -> LPat Id
+ DsUtils: mkLHsVarPatTup :: [Id] -> LPat GhcTc
- DsUtils: mkSelectorBinds :: [[Tickish Id]] -> LPat Id -> CoreExpr -> DsM (Id, [(Id, CoreExpr)])
+ DsUtils: mkSelectorBinds :: [[Tickish Id]] -> LPat GhcTc -> CoreExpr -> DsM (Id, [(Id, CoreExpr)])
- DsUtils: mkVanillaTuplePat :: [OutPat Id] -> Boxity -> Pat Id
+ DsUtils: mkVanillaTuplePat :: [OutPat GhcTc] -> Boxity -> Pat GhcTc
- DsUtils: selectMatchVar :: Pat Id -> DsM Id
+ DsUtils: selectMatchVar :: Pat GhcTc -> DsM Id
- DsUtils: selectMatchVars :: [Pat Id] -> DsM [Id]
+ DsUtils: selectMatchVars :: [Pat GhcTc] -> DsM [Id]
- DsUtils: selectSimpleMatchVarL :: LPat Id -> DsM Id
+ DsUtils: selectSimpleMatchVarL :: LPat GhcTc -> DsM Id
- DynFlags: DynFlags :: GhcMode -> GhcLink -> HscTarget -> Settings -> Int -> Int -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> [FilePath] -> Module -> Maybe String -> IntWithInf -> IntWithInf -> InstalledUnitId -> Maybe ComponentId -> Maybe [(ModuleName, Module)] -> [Way] -> String -> String -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe FilePath -> Maybe [Set String] -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> [String] -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> Hooks -> FilePath -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> Maybe [(FilePath, [PackageConfig])] -> PackageState -> IORef [FilePath] -> IORef (Map FilePath FilePath) -> IORef [FilePath] -> IORef Int -> IORef (Set FilePath) -> IntSet -> IntSet -> IntSet -> IntSet -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff Extension] -> IntSet -> Int -> Int -> Int -> Int -> Float -> Int -> Bool -> Int -> Int -> IO (Maybe LogOutput) -> LogAction -> LogFinaliser -> FlushOut -> FlushErr -> Maybe String -> [String] -> Int -> Int -> Bool -> OverridingBool -> Bool -> Scheme -> ProfAuto -> Maybe String -> IORef (ModuleEnv Int) -> Maybe SseVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IORef (Maybe LinkerInfo) -> IORef (Maybe CompilerInfo) -> Int -> Int -> Int -> Bool -> Maybe Int -> Int -> Int -> DynFlags
+ DynFlags: DynFlags :: GhcMode -> GhcLink -> HscTarget -> Settings -> LlvmTargets -> Int -> Int -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Maybe Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> [FilePath] -> Module -> Maybe String -> IntWithInf -> IntWithInf -> InstalledUnitId -> Maybe ComponentId -> Maybe [(ModuleName, Module)] -> [Way] -> String -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> [String] -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> Hooks -> FilePath -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> Maybe [(FilePath, [PackageConfig])] -> PackageState -> IORef FilesToClean -> IORef (Map FilePath FilePath) -> IORef Int -> IORef (Set FilePath) -> EnumSet DumpFlag -> EnumSet GeneralFlag -> EnumSet WarningFlag -> EnumSet WarningFlag -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff Extension] -> EnumSet Extension -> Int -> Int -> Int -> Int -> Float -> Int -> Bool -> Int -> Int -> IO (Maybe LogOutput) -> LogAction -> LogFinaliser -> FlushOut -> FlushErr -> Maybe FilePath -> Maybe String -> [String] -> Int -> Int -> Bool -> OverridingBool -> Bool -> Scheme -> ProfAuto -> Maybe String -> IORef (ModuleEnv Int) -> Maybe SseVersion -> Maybe BmiVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IORef (Maybe LinkerInfo) -> IORef (Maybe CompilerInfo) -> Int -> Int -> Int -> Bool -> Maybe Int -> Int -> Int -> DynFlags
- DynFlags: Settings :: Platform -> FilePath -> FilePath -> FilePath -> String -> String -> String -> [(String, String)] -> [String] -> FilePath -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> (String, [Option]) -> String -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> String -> String -> String -> (String, [Option]) -> (String, [Option]) -> String -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> PlatformConstants -> Settings
+ DynFlags: Settings :: Platform -> FilePath -> FilePath -> FilePath -> String -> String -> String -> [(String, String)] -> [String] -> FilePath -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> (String, [Option]) -> String -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> String -> String -> String -> String -> String -> (String, [Option]) -> (String, [Option]) -> (String, [Option]) -> String -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> PlatformConstants -> Settings
- DynFlags: [dumpFlags] :: DynFlags -> IntSet
+ DynFlags: [dumpFlags] :: DynFlags -> EnumSet DumpFlag
- DynFlags: [extensionFlags] :: DynFlags -> IntSet
+ DynFlags: [extensionFlags] :: DynFlags -> EnumSet Extension
- DynFlags: [fatalWarningFlags] :: DynFlags -> IntSet
+ DynFlags: [fatalWarningFlags] :: DynFlags -> EnumSet WarningFlag
- DynFlags: [filesToClean] :: DynFlags -> IORef [FilePath]
+ DynFlags: [filesToClean] :: DynFlags -> IORef FilesToClean
- DynFlags: [generalFlags] :: DynFlags -> IntSet
+ DynFlags: [generalFlags] :: DynFlags -> EnumSet GeneralFlag
- DynFlags: [warningFlags] :: DynFlags -> IntSet
+ DynFlags: [warningFlags] :: DynFlags -> EnumSet WarningFlag
- DynFlags: defaultDynFlags :: Settings -> DynFlags
+ DynFlags: defaultDynFlags :: Settings -> LlvmTargets -> DynFlags
- DynFlags: parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
+ DynFlags: parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
- DynFlags: parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
+ DynFlags: parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
- DynFlags: parseDynamicFlagsFull :: MonadIO m => [Flag (CmdLineP DynFlags)] -> Bool -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
+ DynFlags: parseDynamicFlagsFull :: MonadIO m => [Flag (CmdLineP DynFlags)] -> Bool -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
- Elf: makeElfNote :: DynFlags -> String -> String -> Word32 -> String -> SDoc
+ Elf: makeElfNote :: String -> String -> Word32 -> String -> SDoc
- ErrUtils: isWarnMsgFatal :: DynFlags -> WarnMsg -> Bool
+ ErrUtils: isWarnMsgFatal :: DynFlags -> WarnMsg -> Maybe (Maybe WarningFlag)
- FamInst: checkFamInstConsistency :: [Module] -> [Module] -> TcM TcGblEnv
+ FamInst: checkFamInstConsistency :: [Module] -> TcM ()
- Fingerprint: data Fingerprint :: *
+ Fingerprint: data Fingerprint
- GHC: DynFlags :: GhcMode -> GhcLink -> HscTarget -> Settings -> Int -> Int -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> [FilePath] -> Module -> Maybe String -> IntWithInf -> IntWithInf -> InstalledUnitId -> Maybe ComponentId -> Maybe [(ModuleName, Module)] -> [Way] -> String -> String -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe FilePath -> Maybe [Set String] -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> [String] -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> Hooks -> FilePath -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> Maybe [(FilePath, [PackageConfig])] -> PackageState -> IORef [FilePath] -> IORef (Map FilePath FilePath) -> IORef [FilePath] -> IORef Int -> IORef (Set FilePath) -> IntSet -> IntSet -> IntSet -> IntSet -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff Extension] -> IntSet -> Int -> Int -> Int -> Int -> Float -> Int -> Bool -> Int -> Int -> IO (Maybe LogOutput) -> LogAction -> LogFinaliser -> FlushOut -> FlushErr -> Maybe String -> [String] -> Int -> Int -> Bool -> OverridingBool -> Bool -> Scheme -> ProfAuto -> Maybe String -> IORef (ModuleEnv Int) -> Maybe SseVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IORef (Maybe LinkerInfo) -> IORef (Maybe CompilerInfo) -> Int -> Int -> Int -> Bool -> Maybe Int -> Int -> Int -> DynFlags
+ GHC: DynFlags :: GhcMode -> GhcLink -> HscTarget -> Settings -> LlvmTargets -> Int -> Int -> Int -> Int -> Int -> Int -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Maybe Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Maybe Int -> Maybe Int -> Int -> [FilePath] -> Module -> Maybe String -> IntWithInf -> IntWithInf -> InstalledUnitId -> Maybe ComponentId -> Maybe [(ModuleName, Module)] -> [Way] -> String -> Maybe (String, Int) -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> [String] -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> Hooks -> FilePath -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> Maybe [(FilePath, [PackageConfig])] -> PackageState -> IORef FilesToClean -> IORef (Map FilePath FilePath) -> IORef Int -> IORef (Set FilePath) -> EnumSet DumpFlag -> EnumSet GeneralFlag -> EnumSet WarningFlag -> EnumSet WarningFlag -> Maybe Language -> SafeHaskellMode -> Bool -> Bool -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> SrcSpan -> [OnOff Extension] -> EnumSet Extension -> Int -> Int -> Int -> Int -> Float -> Int -> Bool -> Int -> Int -> IO (Maybe LogOutput) -> LogAction -> LogFinaliser -> FlushOut -> FlushErr -> Maybe FilePath -> Maybe String -> [String] -> Int -> Int -> Bool -> OverridingBool -> Bool -> Scheme -> ProfAuto -> Maybe String -> IORef (ModuleEnv Int) -> Maybe SseVersion -> Maybe BmiVersion -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IORef (Maybe LinkerInfo) -> IORef (Maybe CompilerInfo) -> Int -> Int -> Int -> Bool -> Maybe Int -> Int -> Int -> DynFlags
- GHC: ExecOptions :: SingleStep -> String -> Int -> (ForeignHValue -> EvalExpr ForeignHValue) -> ExecOptions
+ GHC: ExecOptions :: SingleStep -> String -> Int -> ForeignHValue -> EvalExpr ForeignHValue -> ExecOptions
- GHC: IIDecl :: (ImportDecl RdrName) -> InteractiveImport
+ GHC: IIDecl :: (ImportDecl GhcPs) -> InteractiveImport
- GHC: ModIface :: !Module -> !(Maybe Module) -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !HscSource -> Dependencies -> [Usage] -> ![IfaceExport] -> !Fingerprint -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [(Fingerprint, IfaceDecl)] -> !(Maybe GlobalRdrEnv) -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !Fingerprint -> !IfaceVectInfo -> (OccName -> Maybe WarningTxt) -> (OccName -> Maybe Fixity) -> (OccName -> Maybe (OccName, Fingerprint)) -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> [IfaceCompleteMatch] -> ModIface
+ GHC: ModIface :: !Module -> !(Maybe Module) -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !HscSource -> Dependencies -> [Usage] -> ![IfaceExport] -> !Fingerprint -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [(Fingerprint, IfaceDecl)] -> !(Maybe GlobalRdrEnv) -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !Fingerprint -> !IfaceVectInfo -> OccName -> Maybe WarningTxt -> OccName -> Maybe Fixity -> OccName -> Maybe (OccName, Fingerprint) -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> [IfaceCompleteMatch] -> ModIface
- GHC: [dumpFlags] :: DynFlags -> IntSet
+ GHC: [dumpFlags] :: DynFlags -> EnumSet DumpFlag
- GHC: [extensionFlags] :: DynFlags -> IntSet
+ GHC: [extensionFlags] :: DynFlags -> EnumSet Extension
- GHC: [fatalWarningFlags] :: DynFlags -> IntSet
+ GHC: [fatalWarningFlags] :: DynFlags -> EnumSet WarningFlag
- GHC: [filesToClean] :: DynFlags -> IORef [FilePath]
+ GHC: [filesToClean] :: DynFlags -> IORef FilesToClean
- GHC: [generalFlags] :: DynFlags -> IntSet
+ GHC: [generalFlags] :: DynFlags -> EnumSet GeneralFlag
- GHC: [warningFlags] :: DynFlags -> IntSet
+ GHC: [warningFlags] :: DynFlags -> EnumSet WarningFlag
- GHC: compileParsedExpr :: GhcMonad m => LHsExpr RdrName -> m HValue
+ GHC: compileParsedExpr :: GhcMonad m => LHsExpr GhcPs -> m HValue
- GHC: compileParsedExprRemote :: GhcMonad m => LHsExpr RdrName -> m ForeignHValue
+ GHC: compileParsedExprRemote :: GhcMonad m => LHsExpr GhcPs -> m ForeignHValue
- GHC: data HValue :: *
+ GHC: data HValue
- GHC: getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
+ GHC: getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))
- GHC: getNameToInstancesIndex :: GhcMonad m => m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))
+ GHC: getNameToInstancesIndex :: GhcMonad m => [Module] -> m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))
- GHC: parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
+ GHC: parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
- GHC: parseExpr :: GhcMonad m => String -> m (LHsExpr RdrName)
+ GHC: parseExpr :: GhcMonad m => String -> m (LHsExpr GhcPs)
- GHC: parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
+ GHC: parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs)
- GHC: parser :: String -> DynFlags -> FilePath -> Either ErrorMessages (WarningMessages, Located (HsModule RdrName))
+ GHC: parser :: String -> DynFlags -> FilePath -> (WarningMessages, Either ErrorMessages (Located (HsModule GhcPs)))
- GHC: topSortModuleGraph :: Bool -> [ModSummary] -> Maybe ModuleName -> [SCC ModSummary]
+ GHC: topSortModuleGraph :: Bool -> ModuleGraph -> Maybe ModuleName -> [SCC ModSummary]
- GHC: type ParsedSource = Located (HsModule RdrName)
+ GHC: type ParsedSource = Located (HsModule GhcPs)
- GHC: type RenamedSource = (HsGroup Name, [LImportDecl Name], Maybe [LIE Name], Maybe LHsDocString)
+ GHC: type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe LHsDocString)
- GHC: type TypecheckedSource = LHsBinds Id
+ GHC: type TypecheckedSource = LHsBinds GhcTc
- GHCi: data EvalExpr a :: * -> *
+ GHCi: data EvalExpr a
- GHCi: data EvalResult a :: * -> *
+ GHCi: data EvalResult a
- GHCi: data EvalStatus_ a b :: * -> * -> *
+ GHCi: data EvalStatus_ a b
- GHCi: data Message a :: * -> *
+ GHCi: data Message a
- GhcMake: topSortModuleGraph :: Bool -> [ModSummary] -> Maybe ModuleName -> [SCC ModSummary]
+ GhcMake: topSortModuleGraph :: Bool -> ModuleGraph -> Maybe ModuleName -> [SCC ModSummary]
- GhcMake: type SummaryNode = (ModSummary, Int, [Int])
+ GhcMake: type SummaryNode = Node Int ModSummary
- GhcMonad: Ghc :: (Session -> IO a) -> Ghc a
+ GhcMonad: Ghc :: Session -> IO a -> Ghc a
- GhcMonad: GhcT :: (Session -> m a) -> GhcT m a
+ GhcMonad: GhcT :: Session -> m a -> GhcT m a
- GhcMonad: liftIO :: MonadIO m => forall a. () => IO a -> m a
+ GhcMonad: liftIO :: MonadIO m => IO a -> m a
- HeaderInfo: mkPrelImports :: ModuleName -> SrcSpan -> Bool -> [LImportDecl RdrName] -> [LImportDecl RdrName]
+ HeaderInfo: mkPrelImports :: ModuleName -> SrcSpan -> Bool -> [LImportDecl GhcPs] -> [LImportDecl GhcPs]
- Hooks: dsForeignsHook :: Hooks -> Maybe ([LForeignDecl Id] -> DsM (ForeignStubs, OrdList (Id, CoreExpr)))
+ Hooks: dsForeignsHook :: Hooks -> Maybe ([LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList (Id, CoreExpr)))
- Hooks: runRnSpliceHook :: Hooks -> Maybe (HsSplice Name -> RnM (HsSplice Name))
+ Hooks: runRnSpliceHook :: Hooks -> Maybe (HsSplice GhcRn -> RnM (HsSplice GhcRn))
- Hooks: tcForeignExportsHook :: Hooks -> Maybe ([LForeignDecl Name] -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt))
+ Hooks: tcForeignExportsHook :: Hooks -> Maybe ([LForeignDecl GhcRn] -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt))
- Hooks: tcForeignImportsHook :: Hooks -> Maybe ([LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt))
+ Hooks: tcForeignImportsHook :: Hooks -> Maybe ([LForeignDecl GhcRn] -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt))
- Hoopl.Dataflow: data Block (n :: * -> * -> *) e x :: (* -> * -> *) -> * -> * -> *
+ Hoopl.Dataflow: data Block n e x
- Hoopl.Dataflow: data C :: *
+ Hoopl.Dataflow: data C
- Hoopl.Dataflow: data O :: *
+ Hoopl.Dataflow: data O
- Hoopl.Dataflow: entryLabel :: NonLocal thing => forall x. () => thing C x -> Label
+ Hoopl.Dataflow: entryLabel :: NonLocal thing => thing C x -> Label
- Hoopl.Dataflow: lastNode :: () => Block n x C -> n O C
+ Hoopl.Dataflow: lastNode :: Block n x C -> n O C
- HsBinds: ABE :: id -> id -> HsWrapper -> TcSpecPrags -> ABExport id
+ HsBinds: ABE :: IdP p -> IdP p -> HsWrapper -> TcSpecPrags -> ABExport p
- HsBinds: AbsBinds :: [TyVar] -> [EvVar] -> [ABExport idL] -> [TcEvBinds] -> LHsBinds idL -> HsBindLR idL idR
+ HsBinds: AbsBinds :: [TyVar] -> [EvVar] -> [ABExport idL] -> [TcEvBinds] -> LHsBinds idL -> Bool -> HsBindLR idL idR
- HsBinds: ClassOpSig :: Bool -> [Located name] -> (LHsSigType name) -> Sig name
+ HsBinds: ClassOpSig :: Bool -> [Located (IdP pass)] -> (LHsSigType pass) -> Sig pass
- HsBinds: CompleteMatchSig :: SourceText -> (Located [Located name]) -> (Maybe (Located name)) -> Sig name
+ HsBinds: CompleteMatchSig :: SourceText -> (Located [Located (IdP pass)]) -> (Maybe (Located (IdP pass))) -> Sig pass
- HsBinds: FixSig :: (FixitySig name) -> Sig name
+ HsBinds: FixSig :: (FixitySig pass) -> Sig pass
- HsBinds: FixitySig :: [Located name] -> Fixity -> FixitySig name
+ HsBinds: FixitySig :: [Located (IdP pass)] -> Fixity -> FixitySig pass
- HsBinds: FunBind :: Located idL -> MatchGroup idR (LHsExpr idR) -> HsWrapper -> PostRn idL NameSet -> [Tickish Id] -> HsBindLR idL idR
+ HsBinds: FunBind :: Located (IdP idL) -> MatchGroup idR (LHsExpr idR) -> HsWrapper -> PostRn idL NameSet -> [Tickish Id] -> HsBindLR idL idR
- HsBinds: IPBind :: (Either (Located HsIPName) id) -> (LHsExpr id) -> IPBind id
+ HsBinds: IPBind :: (Either (Located HsIPName) (IdP id)) -> (LHsExpr id) -> IPBind id
- HsBinds: IdSig :: Id -> Sig name
+ HsBinds: IdSig :: Id -> Sig pass
- HsBinds: InlineSig :: (Located name) -> InlinePragma -> Sig name
+ HsBinds: InlineSig :: (Located (IdP pass)) -> InlinePragma -> Sig pass
- HsBinds: MinimalSig :: SourceText -> (LBooleanFormula (Located name)) -> Sig name
+ HsBinds: MinimalSig :: SourceText -> (LBooleanFormula (Located (IdP pass))) -> Sig pass
- HsBinds: PSB :: Located idL -> PostRn idR NameSet -> HsPatSynDetails (Located idR) -> LPat idR -> HsPatSynDir idR -> PatSynBind idL idR
+ HsBinds: PSB :: Located (IdP idL) -> PostRn idR NameSet -> HsPatSynDetails (Located (IdP idR)) -> LPat idR -> HsPatSynDir idR -> PatSynBind idL idR
- HsBinds: PatSynSig :: [Located name] -> (LHsSigType name) -> Sig name
+ HsBinds: PatSynSig :: [Located (IdP pass)] -> (LHsSigType pass) -> Sig pass
- HsBinds: SCCFunSig :: SourceText -> (Located name) -> (Maybe (Located StringLiteral)) -> Sig name
+ HsBinds: SCCFunSig :: SourceText -> (Located (IdP pass)) -> (Maybe (Located StringLiteral)) -> Sig pass
- HsBinds: SpecInstSig :: SourceText -> (LHsSigType name) -> Sig name
+ HsBinds: SpecInstSig :: SourceText -> (LHsSigType pass) -> Sig pass
- HsBinds: SpecSig :: (Located name) -> [LHsSigType name] -> InlinePragma -> Sig name
+ HsBinds: SpecSig :: (Located (IdP pass)) -> [LHsSigType pass] -> InlinePragma -> Sig pass
- HsBinds: TypeSig :: [Located name] -> (LHsSigWcType name) -> Sig name
+ HsBinds: TypeSig :: [Located (IdP pass)] -> (LHsSigWcType pass) -> Sig pass
- HsBinds: ValBindsOut :: [(RecFlag, LHsBinds idL)] -> [LSig Name] -> HsValBindsLR idL idR
+ HsBinds: ValBindsOut :: [(RecFlag, LHsBinds idL)] -> [LSig GhcRn] -> HsValBindsLR idL idR
- HsBinds: VarBind :: idL -> LHsExpr idR -> Bool -> HsBindLR idL idR
+ HsBinds: VarBind :: IdP idL -> LHsExpr idR -> Bool -> HsBindLR idL idR
- HsBinds: [abe_mono] :: ABExport id -> id
+ HsBinds: [abe_mono] :: ABExport p -> IdP p
- HsBinds: [abe_poly] :: ABExport id -> id
+ HsBinds: [abe_poly] :: ABExport p -> IdP p
- HsBinds: [abe_prags] :: ABExport id -> TcSpecPrags
+ HsBinds: [abe_prags] :: ABExport p -> TcSpecPrags
- HsBinds: [abe_wrap] :: ABExport id -> HsWrapper
+ HsBinds: [abe_wrap] :: ABExport p -> HsWrapper
- HsBinds: [fun_id] :: HsBindLR idL idR -> Located idL
+ HsBinds: [fun_id] :: HsBindLR idL idR -> Located (IdP idL)
- HsBinds: [psb_args] :: PatSynBind idL idR -> HsPatSynDetails (Located idR)
+ HsBinds: [psb_args] :: PatSynBind idL idR -> HsPatSynDetails (Located (IdP idR))
- HsBinds: [psb_id] :: PatSynBind idL idR -> Located idL
+ HsBinds: [psb_id] :: PatSynBind idL idR -> Located (IdP idL)
- HsBinds: [var_id] :: HsBindLR idL idR -> idL
+ HsBinds: [var_id] :: HsBindLR idL idR -> IdP idL
- HsBinds: data ABExport id
+ HsBinds: data ABExport p
- HsBinds: data FixitySig name
+ HsBinds: data FixitySig pass
- HsBinds: data Sig name
+ HsBinds: data Sig pass
- HsBinds: pprLHsBinds :: (OutputableBndrId idL, OutputableBndrId idR) => LHsBindsLR idL idR -> SDoc
+ HsBinds: pprLHsBinds :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR) => LHsBindsLR idL idR -> SDoc
- HsBinds: pprLHsBindsForUser :: (OutputableBndrId idL, OutputableBndrId idR, OutputableBndrId id2) => LHsBindsLR idL idR -> [LSig id2] -> [SDoc]
+ HsBinds: pprLHsBindsForUser :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR, SourceTextX id2, OutputableBndrId id2) => LHsBindsLR idL idR -> [LSig id2] -> [SDoc]
- HsBinds: ppr_monobind :: (OutputableBndrId idL, OutputableBndrId idR) => HsBindLR idL idR -> SDoc
+ HsBinds: ppr_monobind :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR) => HsBindLR idL idR -> SDoc
- HsBinds: ppr_sig :: (OutputableBndrId name) => Sig name -> SDoc
+ HsBinds: ppr_sig :: (SourceTextX pass, OutputableBndrId pass) => Sig pass -> SDoc
- HsBinds: type LFixitySig name = Located (FixitySig name)
+ HsBinds: type LFixitySig pass = Located (FixitySig pass)
- HsBinds: type LSig name = Located (Sig name)
+ HsBinds: type LSig pass = Located (Sig pass)
- HsDecls: ClassDecl :: LHsContext name -> Located name -> LHsQTyVars name -> LexicalFixity -> [Located (FunDep (Located name))] -> [LSig name] -> LHsBinds name -> [LFamilyDecl name] -> [LTyFamDefltEqn name] -> [LDocDecl] -> PostRn name NameSet -> TyClDecl name
+ HsDecls: ClassDecl :: LHsContext pass -> Located (IdP pass) -> LHsQTyVars pass -> LexicalFixity -> [Located (FunDep (Located (IdP pass)))] -> [LSig pass] -> LHsBinds pass -> [LFamilyDecl pass] -> [LTyFamDefltEqn pass] -> [LDocDecl] -> PostRn pass NameSet -> TyClDecl pass
- HsDecls: ClosedTypeFamily :: (Maybe [LTyFamInstEqn name]) -> FamilyInfo name
+ HsDecls: ClosedTypeFamily :: (Maybe [LTyFamInstEqn pass]) -> FamilyInfo pass
- HsDecls: ClsInstD :: ClsInstDecl name -> InstDecl name
+ HsDecls: ClsInstD :: ClsInstDecl pass -> InstDecl pass
- HsDecls: ClsInstDecl :: LHsSigType name -> LHsBinds name -> [LSig name] -> [LTyFamInstDecl name] -> [LDataFamInstDecl name] -> Maybe (Located OverlapMode) -> ClsInstDecl name
+ HsDecls: ClsInstDecl :: LHsSigType pass -> LHsBinds pass -> [LSig pass] -> [LTyFamInstDecl pass] -> [LDataFamInstDecl pass] -> Maybe (Located OverlapMode) -> ClsInstDecl pass
- HsDecls: ConDeclGADT :: [Located name] -> LHsSigType name -> Maybe LHsDocString -> ConDecl name
+ HsDecls: ConDeclGADT :: [Located (IdP pass)] -> LHsSigType pass -> Maybe LHsDocString -> ConDecl pass
- HsDecls: ConDeclH98 :: Located name -> Maybe (LHsQTyVars name) -> Maybe (LHsContext name) -> HsConDeclDetails name -> Maybe LHsDocString -> ConDecl name
+ HsDecls: ConDeclH98 :: Located (IdP pass) -> Maybe (LHsQTyVars pass) -> Maybe (LHsContext pass) -> HsConDeclDetails pass -> Maybe LHsDocString -> ConDecl pass
- HsDecls: DataDecl :: Located name -> LHsQTyVars name -> LexicalFixity -> HsDataDefn name -> PostRn name Bool -> PostRn name NameSet -> TyClDecl name
+ HsDecls: DataDecl :: Located (IdP pass) -> LHsQTyVars pass -> LexicalFixity -> HsDataDefn pass -> PostRn pass Bool -> PostRn pass NameSet -> TyClDecl pass
- HsDecls: DataFamInstD :: DataFamInstDecl name -> InstDecl name
+ HsDecls: DataFamInstD :: DataFamInstDecl pass -> InstDecl pass
- HsDecls: DataFamInstDecl :: Located name -> HsTyPats name -> LexicalFixity -> HsDataDefn name -> PostRn name NameSet -> DataFamInstDecl name
+ HsDecls: DataFamInstDecl :: FamInstEqn pass (HsDataDefn pass) -> DataFamInstDecl pass
- HsDecls: DataFamily :: FamilyInfo name
+ HsDecls: DataFamily :: FamilyInfo pass
- HsDecls: DefaultDecl :: [LHsType name] -> DefaultDecl name
+ HsDecls: DefaultDecl :: [LHsType pass] -> DefaultDecl pass
- HsDecls: DerivDecl :: LHsSigType name -> Maybe (Located DerivStrategy) -> Maybe (Located OverlapMode) -> DerivDecl name
+ HsDecls: DerivDecl :: LHsSigType pass -> Maybe (Located DerivStrategy) -> Maybe (Located OverlapMode) -> DerivDecl pass
- HsDecls: FamDecl :: FamilyDecl name -> TyClDecl name
+ HsDecls: FamDecl :: FamilyDecl pass -> TyClDecl pass
- HsDecls: FamilyDecl :: FamilyInfo name -> Located name -> LHsQTyVars name -> LexicalFixity -> LFamilyResultSig name -> Maybe (LInjectivityAnn name) -> FamilyDecl name
+ HsDecls: FamilyDecl :: FamilyInfo pass -> Located (IdP pass) -> LHsQTyVars pass -> LexicalFixity -> LFamilyResultSig pass -> Maybe (LInjectivityAnn pass) -> FamilyDecl pass
- HsDecls: ForeignExport :: Located name -> LHsSigType name -> PostTc name Coercion -> ForeignExport -> ForeignDecl name
+ HsDecls: ForeignExport :: Located (IdP pass) -> LHsSigType pass -> PostTc pass Coercion -> ForeignExport -> ForeignDecl pass
- HsDecls: ForeignImport :: Located name -> LHsSigType name -> PostTc name Coercion -> ForeignImport -> ForeignDecl name
+ HsDecls: ForeignImport :: Located (IdP pass) -> LHsSigType pass -> PostTc pass Coercion -> ForeignImport -> ForeignDecl pass
- HsDecls: HsAnnotation :: SourceText -> (AnnProvenance name) -> (Located (HsExpr name)) -> AnnDecl name
+ HsDecls: HsAnnotation :: SourceText -> (AnnProvenance (IdP pass)) -> (Located (HsExpr pass)) -> AnnDecl pass
- HsDecls: HsDataDefn :: NewOrData -> LHsContext name -> Maybe (Located CType) -> Maybe (LHsKind name) -> [LConDecl name] -> HsDeriving name -> HsDataDefn name
+ HsDecls: HsDataDefn :: NewOrData -> LHsContext pass -> Maybe (Located CType) -> Maybe (LHsKind pass) -> [LConDecl pass] -> HsDeriving pass -> HsDataDefn pass
- HsDecls: HsDerivingClause :: Maybe (Located DerivStrategy) -> Located [LHsSigType name] -> HsDerivingClause name
+ HsDecls: HsDerivingClause :: Maybe (Located DerivStrategy) -> Located [LHsSigType pass] -> HsDerivingClause pass
- HsDecls: HsNoVect :: SourceText -> (Located name) -> VectDecl name
+ HsDecls: HsNoVect :: SourceText -> (Located (IdP pass)) -> VectDecl pass
- HsDecls: HsRule :: (Located (SourceText, RuleName)) -> Activation -> [LRuleBndr name] -> (Located (HsExpr name)) -> (PostRn name NameSet) -> (Located (HsExpr name)) -> (PostRn name NameSet) -> RuleDecl name
+ HsDecls: HsRule :: (Located (SourceText, RuleName)) -> Activation -> [LRuleBndr pass] -> (Located (HsExpr pass)) -> (PostRn pass NameSet) -> (Located (HsExpr pass)) -> (PostRn pass NameSet) -> RuleDecl pass
- HsDecls: HsRules :: SourceText -> [LRuleDecl name] -> RuleDecls name
+ HsDecls: HsRules :: SourceText -> [LRuleDecl pass] -> RuleDecls pass
- HsDecls: HsVect :: SourceText -> (Located name) -> (LHsExpr name) -> VectDecl name
+ HsDecls: HsVect :: SourceText -> (Located (IdP pass)) -> (LHsExpr pass) -> VectDecl pass
- HsDecls: HsVectClassIn :: SourceText -> (Located name) -> VectDecl name
+ HsDecls: HsVectClassIn :: SourceText -> (Located (IdP pass)) -> VectDecl pass
- HsDecls: HsVectClassOut :: Class -> VectDecl name
+ HsDecls: HsVectClassOut :: Class -> VectDecl pass
- HsDecls: HsVectInstIn :: (LHsSigType name) -> VectDecl name
+ HsDecls: HsVectInstIn :: (LHsSigType pass) -> VectDecl pass
- HsDecls: HsVectInstOut :: ClsInst -> VectDecl name
+ HsDecls: HsVectInstOut :: ClsInst -> VectDecl pass
- HsDecls: HsVectTypeIn :: SourceText -> Bool -> (Located name) -> (Maybe (Located name)) -> VectDecl name
+ HsDecls: HsVectTypeIn :: SourceText -> Bool -> (Located (IdP pass)) -> (Maybe (Located (IdP pass))) -> VectDecl pass
- HsDecls: HsVectTypeOut :: Bool -> TyCon -> (Maybe TyCon) -> VectDecl name
+ HsDecls: HsVectTypeOut :: Bool -> TyCon -> (Maybe TyCon) -> VectDecl pass
- HsDecls: InjectivityAnn :: (Located name) -> [Located name] -> InjectivityAnn name
+ HsDecls: InjectivityAnn :: (Located (IdP pass)) -> [Located (IdP pass)] -> InjectivityAnn pass
- HsDecls: KindSig :: (LHsKind name) -> FamilyResultSig name
+ HsDecls: KindSig :: (LHsKind pass) -> FamilyResultSig pass
- HsDecls: NoSig :: FamilyResultSig name
+ HsDecls: NoSig :: FamilyResultSig pass
- HsDecls: OpenTypeFamily :: FamilyInfo name
+ HsDecls: OpenTypeFamily :: FamilyInfo pass
- HsDecls: RoleAnnotDecl :: (Located name) -> [Located (Maybe Role)] -> RoleAnnotDecl name
+ HsDecls: RoleAnnotDecl :: (Located (IdP pass)) -> [Located (Maybe Role)] -> RoleAnnotDecl pass
- HsDecls: RuleBndr :: (Located name) -> RuleBndr name
+ HsDecls: RuleBndr :: (Located (IdP pass)) -> RuleBndr pass
- HsDecls: RuleBndrSig :: (Located name) -> (LHsSigWcType name) -> RuleBndr name
+ HsDecls: RuleBndrSig :: (Located (IdP pass)) -> (LHsSigWcType pass) -> RuleBndr pass
- HsDecls: SynDecl :: Located name -> LHsQTyVars name -> LexicalFixity -> LHsType name -> PostRn name NameSet -> TyClDecl name
+ HsDecls: SynDecl :: Located (IdP pass) -> LHsQTyVars pass -> LexicalFixity -> LHsType pass -> PostRn pass NameSet -> TyClDecl pass
- HsDecls: TyClGroup :: [LTyClDecl name] -> [LRoleAnnotDecl name] -> [LInstDecl name] -> TyClGroup name
+ HsDecls: TyClGroup :: [LTyClDecl pass] -> [LRoleAnnotDecl pass] -> [LInstDecl pass] -> TyClGroup pass
- HsDecls: TyFamInstD :: TyFamInstDecl name -> InstDecl name
+ HsDecls: TyFamInstD :: TyFamInstDecl pass -> InstDecl pass
- HsDecls: TyFamInstDecl :: LTyFamInstEqn name -> PostRn name NameSet -> TyFamInstDecl name
+ HsDecls: TyFamInstDecl :: TyFamInstEqn pass -> TyFamInstDecl pass
- HsDecls: TyVarSig :: (LHsTyVarBndr name) -> FamilyResultSig name
+ HsDecls: TyVarSig :: (LHsTyVarBndr pass) -> FamilyResultSig pass
- HsDecls: Warning :: [Located name] -> WarningTxt -> WarnDecl name
+ HsDecls: Warning :: [Located (IdP pass)] -> WarningTxt -> WarnDecl pass
- HsDecls: Warnings :: SourceText -> [LWarnDecl name] -> WarnDecls name
+ HsDecls: Warnings :: SourceText -> [LWarnDecl pass] -> WarnDecls pass
- HsDecls: [cid_binds] :: ClsInstDecl name -> LHsBinds name
+ HsDecls: [cid_binds] :: ClsInstDecl pass -> LHsBinds pass
- HsDecls: [cid_datafam_insts] :: ClsInstDecl name -> [LDataFamInstDecl name]
+ HsDecls: [cid_datafam_insts] :: ClsInstDecl pass -> [LDataFamInstDecl pass]
- HsDecls: [cid_inst] :: InstDecl name -> ClsInstDecl name
+ HsDecls: [cid_inst] :: InstDecl pass -> ClsInstDecl pass
- HsDecls: [cid_overlap_mode] :: ClsInstDecl name -> Maybe (Located OverlapMode)
+ HsDecls: [cid_overlap_mode] :: ClsInstDecl pass -> Maybe (Located OverlapMode)
- HsDecls: [cid_poly_ty] :: ClsInstDecl name -> LHsSigType name
+ HsDecls: [cid_poly_ty] :: ClsInstDecl pass -> LHsSigType pass
- HsDecls: [cid_sigs] :: ClsInstDecl name -> [LSig name]
+ HsDecls: [cid_sigs] :: ClsInstDecl pass -> [LSig pass]
- HsDecls: [cid_tyfam_insts] :: ClsInstDecl name -> [LTyFamInstDecl name]
+ HsDecls: [cid_tyfam_insts] :: ClsInstDecl pass -> [LTyFamInstDecl pass]
- HsDecls: [con_cxt] :: ConDecl name -> Maybe (LHsContext name)
+ HsDecls: [con_cxt] :: ConDecl pass -> Maybe (LHsContext pass)
- HsDecls: [con_details] :: ConDecl name -> HsConDeclDetails name
+ HsDecls: [con_details] :: ConDecl pass -> HsConDeclDetails pass
- HsDecls: [con_doc] :: ConDecl name -> Maybe LHsDocString
+ HsDecls: [con_doc] :: ConDecl pass -> Maybe LHsDocString
- HsDecls: [con_name] :: ConDecl name -> Located name
+ HsDecls: [con_name] :: ConDecl pass -> Located (IdP pass)
- HsDecls: [con_names] :: ConDecl name -> [Located name]
+ HsDecls: [con_names] :: ConDecl pass -> [Located (IdP pass)]
- HsDecls: [con_qvars] :: ConDecl name -> Maybe (LHsQTyVars name)
+ HsDecls: [con_qvars] :: ConDecl pass -> Maybe (LHsQTyVars pass)
- HsDecls: [con_type] :: ConDecl name -> LHsSigType name
+ HsDecls: [con_type] :: ConDecl pass -> LHsSigType pass
- HsDecls: [dd_ND] :: HsDataDefn name -> NewOrData
+ HsDecls: [dd_ND] :: HsDataDefn pass -> NewOrData
- HsDecls: [dd_cType] :: HsDataDefn name -> Maybe (Located CType)
+ HsDecls: [dd_cType] :: HsDataDefn pass -> Maybe (Located CType)
- HsDecls: [dd_cons] :: HsDataDefn name -> [LConDecl name]
+ HsDecls: [dd_cons] :: HsDataDefn pass -> [LConDecl pass]
- HsDecls: [dd_ctxt] :: HsDataDefn name -> LHsContext name
+ HsDecls: [dd_ctxt] :: HsDataDefn pass -> LHsContext pass
- HsDecls: [dd_derivs] :: HsDataDefn name -> HsDeriving name
+ HsDecls: [dd_derivs] :: HsDataDefn pass -> HsDeriving pass
- HsDecls: [dd_kindSig] :: HsDataDefn name -> Maybe (LHsKind name)
+ HsDecls: [dd_kindSig] :: HsDataDefn pass -> Maybe (LHsKind pass)
- HsDecls: [deriv_clause_strategy] :: HsDerivingClause name -> Maybe (Located DerivStrategy)
+ HsDecls: [deriv_clause_strategy] :: HsDerivingClause pass -> Maybe (Located DerivStrategy)
- HsDecls: [deriv_clause_tys] :: HsDerivingClause name -> Located [LHsSigType name]
+ HsDecls: [deriv_clause_tys] :: HsDerivingClause pass -> Located [LHsSigType pass]
- HsDecls: [deriv_overlap_mode] :: DerivDecl name -> Maybe (Located OverlapMode)
+ HsDecls: [deriv_overlap_mode] :: DerivDecl pass -> Maybe (Located OverlapMode)
- HsDecls: [deriv_strategy] :: DerivDecl name -> Maybe (Located DerivStrategy)
+ HsDecls: [deriv_strategy] :: DerivDecl pass -> Maybe (Located DerivStrategy)
- HsDecls: [deriv_type] :: DerivDecl name -> LHsSigType name
+ HsDecls: [deriv_type] :: DerivDecl pass -> LHsSigType pass
- HsDecls: [dfid_inst] :: InstDecl name -> DataFamInstDecl name
+ HsDecls: [dfid_inst] :: InstDecl pass -> DataFamInstDecl pass
- HsDecls: [fdFixity] :: FamilyDecl name -> LexicalFixity
+ HsDecls: [fdFixity] :: FamilyDecl pass -> LexicalFixity
- HsDecls: [fdInfo] :: FamilyDecl name -> FamilyInfo name
+ HsDecls: [fdInfo] :: FamilyDecl pass -> FamilyInfo pass
- HsDecls: [fdInjectivityAnn] :: FamilyDecl name -> Maybe (LInjectivityAnn name)
+ HsDecls: [fdInjectivityAnn] :: FamilyDecl pass -> Maybe (LInjectivityAnn pass)
- HsDecls: [fdLName] :: FamilyDecl name -> Located name
+ HsDecls: [fdLName] :: FamilyDecl pass -> Located (IdP pass)
- HsDecls: [fdResultSig] :: FamilyDecl name -> LFamilyResultSig name
+ HsDecls: [fdResultSig] :: FamilyDecl pass -> LFamilyResultSig pass
- HsDecls: [fdTyVars] :: FamilyDecl name -> LHsQTyVars name
+ HsDecls: [fdTyVars] :: FamilyDecl pass -> LHsQTyVars pass
- HsDecls: [fd_co] :: ForeignDecl name -> PostTc name Coercion
+ HsDecls: [fd_co] :: ForeignDecl pass -> PostTc pass Coercion
- HsDecls: [fd_fe] :: ForeignDecl name -> ForeignExport
+ HsDecls: [fd_fe] :: ForeignDecl pass -> ForeignExport
- HsDecls: [fd_fi] :: ForeignDecl name -> ForeignImport
+ HsDecls: [fd_fi] :: ForeignDecl pass -> ForeignImport
- HsDecls: [fd_name] :: ForeignDecl name -> Located name
+ HsDecls: [fd_name] :: ForeignDecl pass -> Located (IdP pass)
- HsDecls: [fd_sig_ty] :: ForeignDecl name -> LHsSigType name
+ HsDecls: [fd_sig_ty] :: ForeignDecl pass -> LHsSigType pass
- HsDecls: [group_instds] :: TyClGroup name -> [LInstDecl name]
+ HsDecls: [group_instds] :: TyClGroup pass -> [LInstDecl pass]
- HsDecls: [group_roles] :: TyClGroup name -> [LRoleAnnotDecl name]
+ HsDecls: [group_roles] :: TyClGroup pass -> [LRoleAnnotDecl pass]
- HsDecls: [group_tyclds] :: TyClGroup name -> [LTyClDecl name]
+ HsDecls: [group_tyclds] :: TyClGroup pass -> [LTyClDecl pass]
- HsDecls: [rds_rules] :: RuleDecls name -> [LRuleDecl name]
+ HsDecls: [rds_rules] :: RuleDecls pass -> [LRuleDecl pass]
- HsDecls: [rds_src] :: RuleDecls name -> SourceText
+ HsDecls: [rds_src] :: RuleDecls pass -> SourceText
- HsDecls: [tcdATDefs] :: TyClDecl name -> [LTyFamDefltEqn name]
+ HsDecls: [tcdATDefs] :: TyClDecl pass -> [LTyFamDefltEqn pass]
- HsDecls: [tcdATs] :: TyClDecl name -> [LFamilyDecl name]
+ HsDecls: [tcdATs] :: TyClDecl pass -> [LFamilyDecl pass]
- HsDecls: [tcdCtxt] :: TyClDecl name -> LHsContext name
+ HsDecls: [tcdCtxt] :: TyClDecl pass -> LHsContext pass
- HsDecls: [tcdDataCusk] :: TyClDecl name -> PostRn name Bool
+ HsDecls: [tcdDataCusk] :: TyClDecl pass -> PostRn pass Bool
- HsDecls: [tcdDataDefn] :: TyClDecl name -> HsDataDefn name
+ HsDecls: [tcdDataDefn] :: TyClDecl pass -> HsDataDefn pass
- HsDecls: [tcdDocs] :: TyClDecl name -> [LDocDecl]
+ HsDecls: [tcdDocs] :: TyClDecl pass -> [LDocDecl]
- HsDecls: [tcdFDs] :: TyClDecl name -> [Located (FunDep (Located name))]
+ HsDecls: [tcdFDs] :: TyClDecl pass -> [Located (FunDep (Located (IdP pass)))]
- HsDecls: [tcdFVs] :: TyClDecl name -> PostRn name NameSet
+ HsDecls: [tcdFVs] :: TyClDecl pass -> PostRn pass NameSet
- HsDecls: [tcdFam] :: TyClDecl name -> FamilyDecl name
+ HsDecls: [tcdFam] :: TyClDecl pass -> FamilyDecl pass
- HsDecls: [tcdFixity] :: TyClDecl name -> LexicalFixity
+ HsDecls: [tcdFixity] :: TyClDecl pass -> LexicalFixity
- HsDecls: [tcdLName] :: TyClDecl name -> Located name
+ HsDecls: [tcdLName] :: TyClDecl pass -> Located (IdP pass)
- HsDecls: [tcdMeths] :: TyClDecl name -> LHsBinds name
+ HsDecls: [tcdMeths] :: TyClDecl pass -> LHsBinds pass
- HsDecls: [tcdRhs] :: TyClDecl name -> LHsType name
+ HsDecls: [tcdRhs] :: TyClDecl pass -> LHsType pass
- HsDecls: [tcdSigs] :: TyClDecl name -> [LSig name]
+ HsDecls: [tcdSigs] :: TyClDecl pass -> [LSig pass]
- HsDecls: [tcdTyVars] :: TyClDecl name -> LHsQTyVars name
+ HsDecls: [tcdTyVars] :: TyClDecl pass -> LHsQTyVars pass
- HsDecls: [tfid_eqn] :: TyFamInstDecl name -> LTyFamInstEqn name
+ HsDecls: [tfid_eqn] :: TyFamInstDecl pass -> TyFamInstEqn pass
- HsDecls: [tfid_inst] :: InstDecl name -> TyFamInstDecl name
+ HsDecls: [tfid_inst] :: InstDecl pass -> TyFamInstDecl pass
- HsDecls: [wd_src] :: WarnDecls name -> SourceText
+ HsDecls: [wd_src] :: WarnDecls pass -> SourceText
- HsDecls: [wd_warnings] :: WarnDecls name -> [LWarnDecl name]
+ HsDecls: [wd_warnings] :: WarnDecls pass -> [LWarnDecl pass]
- HsDecls: collectRuleBndrSigTys :: [RuleBndr name] -> [LHsSigWcType name]
+ HsDecls: collectRuleBndrSigTys :: [RuleBndr pass] -> [LHsSigWcType pass]
- HsDecls: countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int)
+ HsDecls: countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)
- HsDecls: data AnnDecl name
+ HsDecls: data AnnDecl pass
- HsDecls: data ClsInstDecl name
+ HsDecls: data ClsInstDecl pass
- HsDecls: data ConDecl name
+ HsDecls: data ConDecl pass
- HsDecls: data DefaultDecl name
+ HsDecls: data DefaultDecl pass
- HsDecls: data DerivDecl name
+ HsDecls: data DerivDecl pass
- HsDecls: data FamilyDecl name
+ HsDecls: data FamilyDecl pass
- HsDecls: data FamilyInfo name
+ HsDecls: data FamilyInfo pass
- HsDecls: data FamilyResultSig name
+ HsDecls: data FamilyResultSig pass
- HsDecls: data ForeignDecl name
+ HsDecls: data ForeignDecl pass
- HsDecls: data HsDataDefn name
+ HsDecls: data HsDataDefn pass
- HsDecls: data HsDerivingClause name
+ HsDecls: data HsDerivingClause pass
- HsDecls: data InjectivityAnn name
+ HsDecls: data InjectivityAnn pass
- HsDecls: data InstDecl name
+ HsDecls: data InstDecl pass
- HsDecls: data RoleAnnotDecl name
+ HsDecls: data RoleAnnotDecl pass
- HsDecls: data RuleBndr name
+ HsDecls: data RuleBndr pass
- HsDecls: data RuleDecl name
+ HsDecls: data RuleDecl pass
- HsDecls: data RuleDecls name
+ HsDecls: data RuleDecls pass
- HsDecls: data TyClDecl name
+ HsDecls: data TyClDecl pass
- HsDecls: data TyClGroup name
+ HsDecls: data TyClGroup pass
- HsDecls: data VectDecl name
+ HsDecls: data VectDecl pass
- HsDecls: data WarnDecl name
+ HsDecls: data WarnDecl pass
- HsDecls: data WarnDecls name
+ HsDecls: data WarnDecls pass
- HsDecls: emptyTyClGroup :: TyClGroup name
+ HsDecls: emptyTyClGroup :: TyClGroup pass
- HsDecls: famDeclHasCusk :: Maybe Bool -> FamilyDecl name -> Bool
+ HsDecls: famDeclHasCusk :: Maybe Bool -> FamilyDecl pass -> Bool
- HsDecls: flattenRuleDecls :: [LRuleDecls name] -> [LRuleDecl name]
+ HsDecls: flattenRuleDecls :: [LRuleDecls pass] -> [LRuleDecl pass]
- HsDecls: gadtDeclDetails :: LHsSigType name -> (HsConDeclDetails name, LHsType name, LHsContext name, [LHsTyVarBndr name])
+ HsDecls: gadtDeclDetails :: LHsSigType pass -> (HsConDeclDetails pass, LHsType pass, LHsContext pass, [LHsTyVarBndr pass])
- HsDecls: getConDetails :: ConDecl name -> HsConDeclDetails name
+ HsDecls: getConDetails :: ConDecl pass -> HsConDeclDetails pass
- HsDecls: getConNames :: ConDecl name -> [Located name]
+ HsDecls: getConNames :: ConDecl pass -> [Located (IdP pass)]
- HsDecls: hsConDeclArgTys :: HsConDeclDetails name -> [LBangType name]
+ HsDecls: hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass]
- HsDecls: hsDeclHasCusk :: TyClDecl Name -> Bool
+ HsDecls: hsDeclHasCusk :: TyClDecl GhcRn -> Bool
- HsDecls: instDeclDataFamInsts :: [LInstDecl name] -> [DataFamInstDecl name]
+ HsDecls: instDeclDataFamInsts :: [LInstDecl pass] -> [DataFamInstDecl pass]
- HsDecls: isClassDecl :: TyClDecl name -> Bool
+ HsDecls: isClassDecl :: TyClDecl pass -> Bool
- HsDecls: isClosedTypeFamilyInfo :: FamilyInfo name -> Bool
+ HsDecls: isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool
- HsDecls: isDataDecl :: TyClDecl name -> Bool
+ HsDecls: isDataDecl :: TyClDecl pass -> Bool
- HsDecls: isDataFamilyDecl :: TyClDecl name -> Bool
+ HsDecls: isDataFamilyDecl :: TyClDecl pass -> Bool
- HsDecls: isFamilyDecl :: TyClDecl name -> Bool
+ HsDecls: isFamilyDecl :: TyClDecl pass -> Bool
- HsDecls: isOpenTypeFamilyInfo :: FamilyInfo name -> Bool
+ HsDecls: isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool
- HsDecls: isSynDecl :: TyClDecl name -> Bool
+ HsDecls: isSynDecl :: TyClDecl pass -> Bool
- HsDecls: isTypeFamilyDecl :: TyClDecl name -> Bool
+ HsDecls: isTypeFamilyDecl :: TyClDecl pass -> Bool
- HsDecls: lvectDeclName :: NamedThing name => LVectDecl name -> Name
+ HsDecls: lvectDeclName :: NamedThing (IdP pass) => LVectDecl pass -> Name
- HsDecls: lvectInstDecl :: LVectDecl name -> Bool
+ HsDecls: lvectInstDecl :: LVectDecl pass -> Bool
- HsDecls: mkTyClGroup :: [LTyClDecl name] -> [LInstDecl name] -> TyClGroup name
+ HsDecls: mkTyClGroup :: [LTyClDecl pass] -> [LInstDecl pass] -> TyClGroup pass
- HsDecls: pprDataFamInstFlavour :: DataFamInstDecl name -> SDoc
+ HsDecls: pprDataFamInstFlavour :: DataFamInstDecl pass -> SDoc
- HsDecls: resultVariableName :: FamilyResultSig a -> Maybe a
+ HsDecls: resultVariableName :: FamilyResultSig a -> Maybe (IdP a)
- HsDecls: roleAnnotDeclName :: RoleAnnotDecl name -> name
+ HsDecls: roleAnnotDeclName :: RoleAnnotDecl pass -> (IdP pass)
- HsDecls: tcdName :: TyClDecl name -> name
+ HsDecls: tcdName :: TyClDecl pass -> (IdP pass)
- HsDecls: tyClDeclLName :: TyClDecl name -> Located name
+ HsDecls: tyClDeclLName :: TyClDecl pass -> Located (IdP pass)
- HsDecls: tyClDeclTyVars :: TyClDecl name -> LHsQTyVars name
+ HsDecls: tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass
- HsDecls: tyClGroupInstDecls :: [TyClGroup name] -> [LInstDecl name]
+ HsDecls: tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]
- HsDecls: tyClGroupRoleDecls :: [TyClGroup name] -> [LRoleAnnotDecl name]
+ HsDecls: tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]
- HsDecls: tyClGroupTyClDecls :: [TyClGroup name] -> [LTyClDecl name]
+ HsDecls: tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]
- HsDecls: tyFamInstDeclLName :: TyFamInstDecl name -> Located name
+ HsDecls: tyFamInstDeclLName :: TyFamInstDecl pass -> Located (IdP pass)
- HsDecls: tyFamInstDeclName :: TyFamInstDecl name -> name
+ HsDecls: tyFamInstDeclName :: TyFamInstDecl pass -> (IdP pass)
- HsDecls: type HsConDeclDetails name = HsConDetails (LBangType name) (Located [LConDeclField name])
+ HsDecls: type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass])
- HsDecls: type HsDeriving name = Located [LHsDerivingClause name] The optional @deriving@ clauses of a data declaration. "Clauses" is plural because one can specify multiple deriving clauses using the @-XDerivingStrategies@ language extension. The list of 'LHsDerivingClause's corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.
+ HsDecls: type HsDeriving pass = Located [LHsDerivingClause pass] The optional @deriving@ clauses of a data declaration. "Clauses" is plural because one can specify multiple deriving clauses using the @-XDerivingStrategies@ language extension. The list of 'LHsDerivingClause's corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.
- HsDecls: type HsTyPats name = HsImplicitBndrs name [LHsType name] Type patterns (with kind and type bndrs) See Note [Family instance declaration binders]
+ HsDecls: type HsTyPats pass = [LHsType pass]
- HsDecls: type LAnnDecl name = Located (AnnDecl name)
+ HsDecls: type LAnnDecl pass = Located (AnnDecl pass)
- HsDecls: type LClsInstDecl name = Located (ClsInstDecl name)
+ HsDecls: type LClsInstDecl pass = Located (ClsInstDecl pass)
- HsDecls: type LConDecl name = Located (ConDecl name) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a GADT constructor list
+ HsDecls: type LConDecl pass = Located (ConDecl pass) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a GADT constructor list
- HsDecls: type LDataFamInstDecl name = Located (DataFamInstDecl name)
+ HsDecls: type LDataFamInstDecl pass = Located (DataFamInstDecl pass)
- HsDecls: type LDefaultDecl name = Located (DefaultDecl name)
+ HsDecls: type LDefaultDecl pass = Located (DefaultDecl pass)
- HsDecls: type LDerivDecl name = Located (DerivDecl name)
+ HsDecls: type LDerivDecl pass = Located (DerivDecl pass)
- HsDecls: type LFamilyDecl name = Located (FamilyDecl name)
+ HsDecls: type LFamilyDecl pass = Located (FamilyDecl pass)
- HsDecls: type LFamilyResultSig name = Located (FamilyResultSig name)
+ HsDecls: type LFamilyResultSig pass = Located (FamilyResultSig pass)
- HsDecls: type LForeignDecl name = Located (ForeignDecl name)
+ HsDecls: type LForeignDecl pass = Located (ForeignDecl pass)
- HsDecls: type LHsDerivingClause name = Located (HsDerivingClause name)
+ HsDecls: type LHsDerivingClause pass = Located (HsDerivingClause pass)
- HsDecls: type LInjectivityAnn name = Located (InjectivityAnn name)
+ HsDecls: type LInjectivityAnn pass = Located (InjectivityAnn pass)
- HsDecls: type LInstDecl name = Located (InstDecl name)
+ HsDecls: type LInstDecl pass = Located (InstDecl pass)
- HsDecls: type LRoleAnnotDecl name = Located (RoleAnnotDecl name)
+ HsDecls: type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass)
- HsDecls: type LRuleBndr name = Located (RuleBndr name)
+ HsDecls: type LRuleBndr pass = Located (RuleBndr pass)
- HsDecls: type LRuleDecl name = Located (RuleDecl name)
+ HsDecls: type LRuleDecl pass = Located (RuleDecl pass)
- HsDecls: type LRuleDecls name = Located (RuleDecls name)
+ HsDecls: type LRuleDecls pass = Located (RuleDecls pass)
- HsDecls: type LSpliceDecl name = Located (SpliceDecl name)
+ HsDecls: type LSpliceDecl pass = Located (SpliceDecl pass)
- HsDecls: type LTyClDecl name = Located (TyClDecl name)
+ HsDecls: type LTyClDecl pass = Located (TyClDecl pass)
- HsDecls: type LTyFamDefltEqn name = Located (TyFamDefltEqn name)
+ HsDecls: type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass)
- HsDecls: type LTyFamInstDecl name = Located (TyFamInstDecl name)
+ HsDecls: type LTyFamInstDecl pass = Located (TyFamInstDecl pass)
- HsDecls: type LTyFamInstEqn name = Located (TyFamInstEqn name) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a list
+ HsDecls: type LTyFamInstEqn pass = Located (TyFamInstEqn pass) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a list
- HsDecls: type LVectDecl name = Located (VectDecl name)
+ HsDecls: type LVectDecl pass = Located (VectDecl pass)
- HsDecls: type LWarnDecl name = Located (WarnDecl name)
+ HsDecls: type LWarnDecl pass = Located (WarnDecl pass)
- HsDecls: type LWarnDecls name = Located (WarnDecls name)
+ HsDecls: type LWarnDecls pass = Located (WarnDecls pass)
- HsDecls: type TyFamDefltEqn name = TyFamEqn name (LHsQTyVars name)
+ HsDecls: type TyFamDefltEqn pass = FamEqn pass (LHsQTyVars pass) (LHsType pass)
- HsDecls: type TyFamInstEqn name = TyFamEqn name (HsTyPats name)
+ HsDecls: type TyFamInstEqn pass = FamInstEqn pass (LHsType pass)
- HsDumpAst: showAstData :: Data a => BlankSrcSpan -> a -> String
+ HsDumpAst: showAstData :: Data a => BlankSrcSpan -> a -> SDoc
- HsExpr: ApplicativeArgOne :: (LPat idL) -> (LHsExpr idL) -> ApplicativeArg idL idR
+ HsExpr: ApplicativeArgOne :: (LPat idL) -> (LHsExpr idL) -> Bool -> ApplicativeArg idL idR
- HsExpr: ArithSeq :: PostTcExpr -> (Maybe (SyntaxExpr id)) -> (ArithSeqInfo id) -> HsExpr id
+ HsExpr: ArithSeq :: PostTcExpr -> (Maybe (SyntaxExpr p)) -> (ArithSeqInfo p) -> HsExpr p
- HsExpr: DecBrG :: (HsGroup id) -> HsBracket id
+ HsExpr: DecBrG :: (HsGroup p) -> HsBracket p
- HsExpr: DecBrL :: [LHsDecl id] -> HsBracket id
+ HsExpr: DecBrL :: [LHsDecl p] -> HsBracket p
- HsExpr: EAsPat :: (Located id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: EAsPat :: (Located (IdP p)) -> (LHsExpr p) -> HsExpr p
- HsExpr: ELazyPat :: (LHsExpr id) -> HsExpr id
+ HsExpr: ELazyPat :: (LHsExpr p) -> HsExpr p
- HsExpr: EViewPat :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: EViewPat :: (LHsExpr p) -> (LHsExpr p) -> HsExpr p
- HsExpr: EWildPat :: HsExpr id
+ HsExpr: EWildPat :: HsExpr p
- HsExpr: ExpBr :: (LHsExpr id) -> HsBracket id
+ HsExpr: ExpBr :: (LHsExpr p) -> HsBracket p
- HsExpr: ExplicitList :: (PostTc id Type) -> (Maybe (SyntaxExpr id)) -> [LHsExpr id] -> HsExpr id
+ HsExpr: ExplicitList :: (PostTc p Type) -> (Maybe (SyntaxExpr p)) -> [LHsExpr p] -> HsExpr p
- HsExpr: ExplicitPArr :: (PostTc id Type) -> [LHsExpr id] -> HsExpr id
+ HsExpr: ExplicitPArr :: (PostTc p Type) -> [LHsExpr p] -> HsExpr p
- HsExpr: ExplicitSum :: ConTag -> Arity -> (LHsExpr id) -> (PostTc id [Type]) -> HsExpr id
+ HsExpr: ExplicitSum :: ConTag -> Arity -> (LHsExpr p) -> (PostTc p [Type]) -> HsExpr p
- HsExpr: ExplicitTuple :: [LHsTupArg id] -> Boxity -> HsExpr id
+ HsExpr: ExplicitTuple :: [LHsTupArg p] -> Boxity -> HsExpr p
- HsExpr: ExprWithTySig :: (LHsExpr id) -> (LHsSigWcType id) -> HsExpr id
+ HsExpr: ExprWithTySig :: (LHsExpr p) -> (LHsSigWcType p) -> HsExpr p
- HsExpr: ExprWithTySigOut :: (LHsExpr id) -> (LHsSigWcType Name) -> HsExpr id
+ HsExpr: ExprWithTySigOut :: (LHsExpr p) -> (LHsSigWcType GhcRn) -> HsExpr p
- HsExpr: GRHSs :: [LGRHS id body] -> LHsLocalBinds id -> GRHSs id body
+ HsExpr: GRHSs :: [LGRHS p body] -> LHsLocalBinds p -> GRHSs p body
- HsExpr: HsApp :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsApp :: (LHsExpr p) -> (LHsExpr p) -> HsExpr p
- HsExpr: HsAppType :: (LHsExpr id) -> (LHsWcType id) -> HsExpr id
+ HsExpr: HsAppType :: (LHsExpr p) -> (LHsWcType p) -> HsExpr p
- HsExpr: HsAppTypeOut :: (LHsExpr id) -> (LHsWcType Name) -> HsExpr id
+ HsExpr: HsAppTypeOut :: (LHsExpr p) -> (LHsWcType GhcRn) -> HsExpr p
- HsExpr: HsArrApp :: (LHsExpr id) -> (LHsExpr id) -> (PostTc id Type) -> HsArrAppType -> Bool -> HsExpr id
+ HsExpr: HsArrApp :: (LHsExpr p) -> (LHsExpr p) -> (PostTc p Type) -> HsArrAppType -> Bool -> HsExpr p
- HsExpr: HsArrForm :: (LHsExpr id) -> (Maybe Fixity) -> [LHsCmdTop id] -> HsExpr id
+ HsExpr: HsArrForm :: (LHsExpr p) -> (Maybe Fixity) -> [LHsCmdTop p] -> HsExpr p
- HsExpr: HsBinTick :: Int -> Int -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsBinTick :: Int -> Int -> (LHsExpr p) -> HsExpr p
- HsExpr: HsBracket :: (HsBracket id) -> HsExpr id
+ HsExpr: HsBracket :: (HsBracket p) -> HsExpr p
- HsExpr: HsCase :: (LHsExpr id) -> (MatchGroup id (LHsExpr id)) -> HsExpr id
+ HsExpr: HsCase :: (LHsExpr p) -> (MatchGroup p (LHsExpr p)) -> HsExpr p
- HsExpr: HsCmdTop :: (LHsCmd id) -> (PostTc id Type) -> (PostTc id Type) -> (CmdSyntaxTable id) -> HsCmdTop id
+ HsExpr: HsCmdTop :: (LHsCmd p) -> (PostTc p Type) -> (PostTc p Type) -> (CmdSyntaxTable p) -> HsCmdTop p
- HsExpr: HsConLikeOut :: ConLike -> HsExpr id
+ HsExpr: HsConLikeOut :: ConLike -> HsExpr p
- HsExpr: HsCoreAnn :: SourceText -> StringLiteral -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsCoreAnn :: SourceText -> StringLiteral -> (LHsExpr p) -> HsExpr p
- HsExpr: HsDo :: (HsStmtContext Name) -> (Located [ExprLStmt id]) -> (PostTc id Type) -> HsExpr id
+ HsExpr: HsDo :: (HsStmtContext Name) -> (Located [ExprLStmt p]) -> (PostTc p Type) -> HsExpr p
- HsExpr: HsIPVar :: HsIPName -> HsExpr id
+ HsExpr: HsIPVar :: HsIPName -> HsExpr p
- HsExpr: HsIf :: (Maybe (SyntaxExpr id)) -> (LHsExpr id) -> (LHsExpr id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsIf :: (Maybe (SyntaxExpr p)) -> (LHsExpr p) -> (LHsExpr p) -> (LHsExpr p) -> HsExpr p
- HsExpr: HsLam :: (MatchGroup id (LHsExpr id)) -> HsExpr id
+ HsExpr: HsLam :: (MatchGroup p (LHsExpr p)) -> HsExpr p
- HsExpr: HsLamCase :: (MatchGroup id (LHsExpr id)) -> HsExpr id
+ HsExpr: HsLamCase :: (MatchGroup p (LHsExpr p)) -> HsExpr p
- HsExpr: HsLet :: (LHsLocalBinds id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsLet :: (LHsLocalBinds p) -> (LHsExpr p) -> HsExpr p
- HsExpr: HsLit :: HsLit -> HsExpr id
+ HsExpr: HsLit :: (HsLit p) -> HsExpr p
- HsExpr: HsMultiIf :: (PostTc id Type) -> [LGRHS id (LHsExpr id)] -> HsExpr id
+ HsExpr: HsMultiIf :: (PostTc p Type) -> [LGRHS p (LHsExpr p)] -> HsExpr p
- HsExpr: HsOverLabel :: (Maybe id) -> FastString -> HsExpr id
+ HsExpr: HsOverLabel :: (Maybe (IdP p)) -> FastString -> HsExpr p
- HsExpr: HsOverLit :: (HsOverLit id) -> HsExpr id
+ HsExpr: HsOverLit :: (HsOverLit p) -> HsExpr p
- HsExpr: HsPar :: (LHsExpr id) -> HsExpr id
+ HsExpr: HsPar :: (LHsExpr p) -> HsExpr p
- HsExpr: HsProc :: (LPat id) -> (LHsCmdTop id) -> HsExpr id
+ HsExpr: HsProc :: (LPat p) -> (LHsCmdTop p) -> HsExpr p
- HsExpr: HsQuasiQuote :: id -> id -> SrcSpan -> FastString -> HsSplice id
+ HsExpr: HsQuasiQuote :: (IdP id) -> (IdP id) -> SrcSpan -> FastString -> HsSplice id
- HsExpr: HsRecFld :: (AmbiguousFieldOcc id) -> HsExpr id
+ HsExpr: HsRecFld :: (AmbiguousFieldOcc p) -> HsExpr p
- HsExpr: HsRnBracketOut :: (HsBracket Name) -> [PendingRnSplice] -> HsExpr id
+ HsExpr: HsRnBracketOut :: (HsBracket GhcRn) -> [PendingRnSplice] -> HsExpr p
- HsExpr: HsSCC :: SourceText -> StringLiteral -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsSCC :: SourceText -> StringLiteral -> (LHsExpr p) -> HsExpr p
- HsExpr: HsSpliceE :: (HsSplice id) -> HsExpr id
+ HsExpr: HsSpliceE :: (HsSplice p) -> HsExpr p
- HsExpr: HsStatic :: (PostRn id NameSet) -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsStatic :: (PostRn p NameSet) -> (LHsExpr p) -> HsExpr p
- HsExpr: HsTcBracketOut :: (HsBracket Name) -> [PendingTcSplice] -> HsExpr id
+ HsExpr: HsTcBracketOut :: (HsBracket GhcRn) -> [PendingTcSplice] -> HsExpr p
- HsExpr: HsTick :: (Tickish id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsTick :: (Tickish (IdP p)) -> (LHsExpr p) -> HsExpr p
- HsExpr: HsTickPragma :: SourceText -> (StringLiteral, (Int, Int), (Int, Int)) -> ((SourceText, SourceText), (SourceText, SourceText)) -> (LHsExpr id) -> HsExpr id
+ HsExpr: HsTickPragma :: SourceText -> (StringLiteral, (Int, Int), (Int, Int)) -> ((SourceText, SourceText), (SourceText, SourceText)) -> (LHsExpr p) -> HsExpr p
- HsExpr: HsTypedSplice :: SpliceDecoration -> id -> (LHsExpr id) -> HsSplice id
+ HsExpr: HsTypedSplice :: SpliceDecoration -> (IdP id) -> (LHsExpr id) -> HsSplice id
- HsExpr: HsUnboundVar :: UnboundVar -> HsExpr id
+ HsExpr: HsUnboundVar :: UnboundVar -> HsExpr p
- HsExpr: HsUntypedSplice :: SpliceDecoration -> id -> (LHsExpr id) -> HsSplice id
+ HsExpr: HsUntypedSplice :: SpliceDecoration -> (IdP id) -> (LHsExpr id) -> HsSplice id
- HsExpr: HsVar :: (Located id) -> HsExpr id
+ HsExpr: HsVar :: (Located (IdP p)) -> HsExpr p
- HsExpr: HsWrap :: HsWrapper -> (HsExpr id) -> HsExpr id
+ HsExpr: HsWrap :: HsWrapper -> (HsExpr p) -> HsExpr p
- HsExpr: LHsWcTypeX :: (LHsWcType id) -> LHsWcTypeX
+ HsExpr: LHsWcTypeX :: (LHsWcType p) -> LHsWcTypeX
- HsExpr: MG :: Located [LMatch id body] -> [PostTc id Type] -> PostTc id Type -> Origin -> MatchGroup id body
+ HsExpr: MG :: Located [LMatch p body] -> [PostTc p Type] -> PostTc p Type -> Origin -> MatchGroup p body
- HsExpr: Match :: HsMatchContext (NameOrRdrName id) -> [LPat id] -> (Maybe (LHsType id)) -> (GRHSs id body) -> Match id body
+ HsExpr: Match :: HsMatchContext (NameOrRdrName (IdP p)) -> [LPat p] -> (GRHSs p body) -> Match p body
- HsExpr: NegApp :: (LHsExpr id) -> (SyntaxExpr id) -> HsExpr id
+ HsExpr: NegApp :: (LHsExpr p) -> (SyntaxExpr p) -> HsExpr p
- HsExpr: OpApp :: (LHsExpr id) -> (LHsExpr id) -> (PostRn id Fixity) -> (LHsExpr id) -> HsExpr id
+ HsExpr: OpApp :: (LHsExpr p) -> (LHsExpr p) -> (PostRn p Fixity) -> (LHsExpr p) -> HsExpr p
- HsExpr: PArrSeq :: PostTcExpr -> (ArithSeqInfo id) -> HsExpr id
+ HsExpr: PArrSeq :: PostTcExpr -> (ArithSeqInfo p) -> HsExpr p
- HsExpr: ParStmtBlock :: [ExprLStmt idL] -> [idR] -> (SyntaxExpr idR) -> ParStmtBlock idL idR
+ HsExpr: ParStmtBlock :: [ExprLStmt idL] -> [IdP idR] -> (SyntaxExpr idR) -> ParStmtBlock idL idR
- HsExpr: PatBr :: (LPat id) -> HsBracket id
+ HsExpr: PatBr :: (LPat p) -> HsBracket p
- HsExpr: PendingRnSplice :: UntypedSpliceFlavour -> SplicePointName -> (LHsExpr Name) -> PendingRnSplice
+ HsExpr: PendingRnSplice :: UntypedSpliceFlavour -> SplicePointName -> (LHsExpr GhcRn) -> PendingRnSplice
- HsExpr: PendingTcSplice :: SplicePointName -> (LHsExpr Id) -> PendingTcSplice
+ HsExpr: PendingTcSplice :: SplicePointName -> (LHsExpr GhcTc) -> PendingTcSplice
- HsExpr: RecStmt :: [LStmtLR idL idR body] -> [idR] -> [idR] -> SyntaxExpr idR -> SyntaxExpr idR -> SyntaxExpr idR -> PostTc idR Type -> [PostTcExpr] -> [PostTcExpr] -> PostTc idR Type -> StmtLR idL idR body
+ HsExpr: RecStmt :: [LStmtLR idL idR body] -> [IdP idR] -> [IdP idR] -> SyntaxExpr idR -> SyntaxExpr idR -> SyntaxExpr idR -> PostTc idR Type -> [PostTcExpr] -> [PostTcExpr] -> PostTc idR Type -> StmtLR idL idR body
- HsExpr: RecordCon :: Located id -> PostTc id ConLike -> PostTcExpr -> HsRecordBinds id -> HsExpr id
+ HsExpr: RecordCon :: Located (IdP p) -> PostTc p ConLike -> PostTcExpr -> HsRecordBinds p -> HsExpr p
- HsExpr: RecordUpd :: LHsExpr id -> [LHsRecUpdField id] -> PostTc id [ConLike] -> PostTc id [Type] -> PostTc id [Type] -> PostTc id HsWrapper -> HsExpr id
+ HsExpr: RecordUpd :: LHsExpr p -> [LHsRecUpdField p] -> PostTc p [ConLike] -> PostTc p [Type] -> PostTc p [Type] -> PostTc p HsWrapper -> HsExpr p
- HsExpr: SectionL :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: SectionL :: (LHsExpr p) -> (LHsExpr p) -> HsExpr p
- HsExpr: SectionR :: (LHsExpr id) -> (LHsExpr id) -> HsExpr id
+ HsExpr: SectionR :: (LHsExpr p) -> (LHsExpr p) -> HsExpr p
- HsExpr: SyntaxExpr :: HsExpr id -> [HsWrapper] -> HsWrapper -> SyntaxExpr id
+ HsExpr: SyntaxExpr :: HsExpr p -> [HsWrapper] -> HsWrapper -> SyntaxExpr p
- HsExpr: TExpBr :: (LHsExpr id) -> HsBracket id
+ HsExpr: TExpBr :: (LHsExpr p) -> HsBracket p
- HsExpr: TransStmt :: TransForm -> [ExprLStmt idL] -> [(idR, idR)] -> LHsExpr idR -> Maybe (LHsExpr idR) -> SyntaxExpr idR -> SyntaxExpr idR -> PostTc idR Type -> HsExpr idR -> StmtLR idL idR body
+ HsExpr: TransStmt :: TransForm -> [ExprLStmt idL] -> [(IdP idR, IdP idR)] -> LHsExpr idR -> Maybe (LHsExpr idR) -> SyntaxExpr idR -> SyntaxExpr idR -> PostTc idR Type -> HsExpr idR -> StmtLR idL idR body
- HsExpr: TypBr :: (LHsType id) -> HsBracket id
+ HsExpr: TypBr :: (LHsType p) -> HsBracket p
- HsExpr: VarBr :: Bool -> id -> HsBracket id
+ HsExpr: VarBr :: Bool -> (IdP p) -> HsBracket p
- HsExpr: [grhssGRHSs] :: GRHSs id body -> [LGRHS id body]
+ HsExpr: [grhssGRHSs] :: GRHSs p body -> [LGRHS p body]
- HsExpr: [grhssLocalBinds] :: GRHSs id body -> LHsLocalBinds id
+ HsExpr: [grhssLocalBinds] :: GRHSs p body -> LHsLocalBinds p
- HsExpr: [m_ctxt] :: Match id body -> HsMatchContext (NameOrRdrName id)
+ HsExpr: [m_ctxt] :: Match p body -> HsMatchContext (NameOrRdrName (IdP p))
- HsExpr: [m_grhss] :: Match id body -> (GRHSs id body)
+ HsExpr: [m_grhss] :: Match p body -> (GRHSs p body)
- HsExpr: [m_pats] :: Match id body -> [LPat id]
+ HsExpr: [m_pats] :: Match p body -> [LPat p]
- HsExpr: [mg_alts] :: MatchGroup id body -> Located [LMatch id body]
+ HsExpr: [mg_alts] :: MatchGroup p body -> Located [LMatch p body]
- HsExpr: [mg_arg_tys] :: MatchGroup id body -> [PostTc id Type]
+ HsExpr: [mg_arg_tys] :: MatchGroup p body -> [PostTc p Type]
- HsExpr: [mg_origin] :: MatchGroup id body -> Origin
+ HsExpr: [mg_origin] :: MatchGroup p body -> Origin
- HsExpr: [mg_res_ty] :: MatchGroup id body -> PostTc id Type
+ HsExpr: [mg_res_ty] :: MatchGroup p body -> PostTc p Type
- HsExpr: [rcon_con_expr] :: HsExpr id -> PostTcExpr
+ HsExpr: [rcon_con_expr] :: HsExpr p -> PostTcExpr
- HsExpr: [rcon_con_like] :: HsExpr id -> PostTc id ConLike
+ HsExpr: [rcon_con_like] :: HsExpr p -> PostTc p ConLike
- HsExpr: [rcon_con_name] :: HsExpr id -> Located id
+ HsExpr: [rcon_con_name] :: HsExpr p -> Located (IdP p)
- HsExpr: [rcon_flds] :: HsExpr id -> HsRecordBinds id
+ HsExpr: [rcon_flds] :: HsExpr p -> HsRecordBinds p
- HsExpr: [recS_later_ids] :: StmtLR idL idR body -> [idR]
+ HsExpr: [recS_later_ids] :: StmtLR idL idR body -> [IdP idR]
- HsExpr: [recS_rec_ids] :: StmtLR idL idR body -> [idR]
+ HsExpr: [recS_rec_ids] :: StmtLR idL idR body -> [IdP idR]
- HsExpr: [rupd_cons] :: HsExpr id -> PostTc id [ConLike]
+ HsExpr: [rupd_cons] :: HsExpr p -> PostTc p [ConLike]
- HsExpr: [rupd_expr] :: HsExpr id -> LHsExpr id
+ HsExpr: [rupd_expr] :: HsExpr p -> LHsExpr p
- HsExpr: [rupd_flds] :: HsExpr id -> [LHsRecUpdField id]
+ HsExpr: [rupd_flds] :: HsExpr p -> [LHsRecUpdField p]
- HsExpr: [rupd_in_tys] :: HsExpr id -> PostTc id [Type]
+ HsExpr: [rupd_in_tys] :: HsExpr p -> PostTc p [Type]
- HsExpr: [rupd_out_tys] :: HsExpr id -> PostTc id [Type]
+ HsExpr: [rupd_out_tys] :: HsExpr p -> PostTc p [Type]
- HsExpr: [rupd_wrap] :: HsExpr id -> PostTc id HsWrapper
+ HsExpr: [rupd_wrap] :: HsExpr p -> PostTc p HsWrapper
- HsExpr: [syn_arg_wraps] :: SyntaxExpr id -> [HsWrapper]
+ HsExpr: [syn_arg_wraps] :: SyntaxExpr p -> [HsWrapper]
- HsExpr: [syn_expr] :: SyntaxExpr id -> HsExpr id
+ HsExpr: [syn_expr] :: SyntaxExpr p -> HsExpr p
- HsExpr: [syn_res_wrap] :: SyntaxExpr id -> HsWrapper
+ HsExpr: [syn_res_wrap] :: SyntaxExpr p -> HsWrapper
- HsExpr: [trS_bndrs] :: StmtLR idL idR body -> [(idR, idR)]
+ HsExpr: [trS_bndrs] :: StmtLR idL idR body -> [(IdP idR, IdP idR)]
- HsExpr: data GRHSs id body
+ HsExpr: data GRHSs p body
- HsExpr: data HsBracket id
+ HsExpr: data HsBracket p
- HsExpr: data HsCmdTop id
+ HsExpr: data HsCmdTop p
- HsExpr: data HsExpr id
+ HsExpr: data HsExpr p
- HsExpr: data Match id body
+ HsExpr: data Match p body
- HsExpr: data MatchGroup id body
+ HsExpr: data MatchGroup p body
- HsExpr: data SyntaxExpr id
+ HsExpr: data SyntaxExpr p
- HsExpr: mkRnSyntaxExpr :: Name -> SyntaxExpr Name
+ HsExpr: mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn
- HsExpr: noExpr :: HsExpr id
+ HsExpr: noExpr :: SourceTextX p => HsExpr p
- HsExpr: noSyntaxExpr :: SyntaxExpr id
+ HsExpr: noSyntaxExpr :: SourceTextX p => SyntaxExpr p
- HsExpr: pprBinds :: (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR idL idR -> SDoc
+ HsExpr: pprBinds :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR idL idR -> SDoc
- HsExpr: pprCmd :: (OutputableBndrId id) => HsCmd id -> SDoc
+ HsExpr: pprCmd :: (SourceTextX p, OutputableBndrId p) => HsCmd p -> SDoc
- HsExpr: pprCmdArg :: (OutputableBndrId id) => HsCmdTop id -> SDoc
+ HsExpr: pprCmdArg :: (SourceTextX p, OutputableBndrId p) => HsCmdTop p -> SDoc
- HsExpr: pprComp :: (OutputableBndrId id, Outputable body) => [LStmt id body] -> SDoc
+ HsExpr: pprComp :: (SourceTextX p, OutputableBndrId p, Outputable body) => [LStmt p body] -> SDoc
- HsExpr: pprDebugParendExpr :: (OutputableBndrId id) => LHsExpr id -> SDoc
+ HsExpr: pprDebugParendExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc
- HsExpr: pprDo :: (OutputableBndrId id, Outputable body) => HsStmtContext any -> [LStmt id body] -> SDoc
+ HsExpr: pprDo :: (SourceTextX p, OutputableBndrId p, Outputable body) => HsStmtContext any -> [LStmt p body] -> SDoc
- HsExpr: pprExpr :: (OutputableBndrId id) => HsExpr id -> SDoc
+ HsExpr: pprExpr :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc
- HsExpr: pprFunBind :: (OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc
+ HsExpr: pprFunBind :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc
- HsExpr: pprGRHS :: (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHS idR body -> SDoc
+ HsExpr: pprGRHS :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHS idR body -> SDoc
- HsExpr: pprGRHSs :: (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHSs idR body -> SDoc
+ HsExpr: pprGRHSs :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHSs idR body -> SDoc
- HsExpr: pprHsBracket :: (OutputableBndrId id) => HsBracket id -> SDoc
+ HsExpr: pprHsBracket :: (SourceTextX p, OutputableBndrId p) => HsBracket p -> SDoc
- HsExpr: pprLCmd :: (OutputableBndrId id) => LHsCmd id -> SDoc
+ HsExpr: pprLCmd :: (SourceTextX p, OutputableBndrId p) => LHsCmd p -> SDoc
- HsExpr: pprLExpr :: (OutputableBndrId id) => LHsExpr id -> SDoc
+ HsExpr: pprLExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc
- HsExpr: pprMatch :: (OutputableBndrId idR, Outputable body) => Match idR body -> SDoc
+ HsExpr: pprMatch :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => Match idR body -> SDoc
- HsExpr: pprMatchInCtxt :: (OutputableBndrId idR, Outputable (NameOrRdrName (NameOrRdrName idR)), Outputable body) => Match idR body -> SDoc
+ HsExpr: pprMatchInCtxt :: (SourceTextX idR, OutputableBndrId idR, Outputable (NameOrRdrName (NameOrRdrName (IdP idR))), Outputable body) => Match idR body -> SDoc
- HsExpr: pprMatches :: (OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc
+ HsExpr: pprMatches :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc
- HsExpr: pprParendExpr :: (OutputableBndrId id) => HsExpr id -> SDoc
+ HsExpr: pprParendExpr :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc
- HsExpr: pprParendLExpr :: (OutputableBndrId id) => LHsExpr id -> SDoc
+ HsExpr: pprParendLExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc
- HsExpr: pprPatBind :: forall bndr id body. (OutputableBndrId bndr, OutputableBndrId id, Outputable body) => LPat bndr -> GRHSs id body -> SDoc
+ HsExpr: pprPatBind :: forall bndr p body. (SourceTextX p, SourceTextX bndr, OutputableBndrId bndr, OutputableBndrId p, Outputable body) => LPat bndr -> GRHSs p body -> SDoc
- HsExpr: pprPendingSplice :: (OutputableBndrId id) => SplicePointName -> LHsExpr id -> SDoc
+ HsExpr: pprPendingSplice :: (SourceTextX p, OutputableBndrId p) => SplicePointName -> LHsExpr p -> SDoc
- HsExpr: pprQuals :: (OutputableBndrId id, Outputable body) => [LStmt id body] -> SDoc
+ HsExpr: pprQuals :: (SourceTextX p, OutputableBndrId p, Outputable body) => [LStmt p body] -> SDoc
- HsExpr: pprSplice :: (OutputableBndrId id) => HsSplice id -> SDoc
+ HsExpr: pprSplice :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SDoc
- HsExpr: pprSpliceDecl :: (OutputableBndrId id) => HsSplice id -> SpliceExplicitFlag -> SDoc
+ HsExpr: pprSpliceDecl :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SpliceExplicitFlag -> SDoc
- HsExpr: pprStmt :: forall idL idR body. (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => (StmtLR idL idR body) -> SDoc
+ HsExpr: pprStmt :: forall idL idR body. (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => (StmtLR idL idR body) -> SDoc
- HsExpr: pprStmtInCtxt :: (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => HsStmtContext idL -> StmtLR idL idR body -> SDoc
+ HsExpr: pprStmtInCtxt :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => HsStmtContext (IdP idL) -> StmtLR idL idR body -> SDoc
- HsExpr: pprTransformStmt :: (OutputableBndrId id) => [id] -> LHsExpr id -> Maybe (LHsExpr id) -> SDoc
+ HsExpr: pprTransformStmt :: (SourceTextX p, OutputableBndrId p) => [IdP p] -> LHsExpr p -> Maybe (LHsExpr p) -> SDoc
- HsExpr: ppr_apps :: (OutputableBndrId id) => HsExpr id -> [Either (LHsExpr id) LHsWcTypeX] -> SDoc
+ HsExpr: ppr_apps :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> [Either (LHsExpr p) LHsWcTypeX] -> SDoc
- HsExpr: ppr_cmd :: forall id. (OutputableBndrId id) => HsCmd id -> SDoc
+ HsExpr: ppr_cmd :: forall p. (SourceTextX p, OutputableBndrId p) => HsCmd p -> SDoc
- HsExpr: ppr_do_stmts :: (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => [LStmtLR idL idR body] -> SDoc
+ HsExpr: ppr_do_stmts :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => [LStmtLR idL idR body] -> SDoc
- HsExpr: ppr_expr :: forall id. (OutputableBndrId id) => HsExpr id -> SDoc
+ HsExpr: ppr_expr :: forall p. (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc
- HsExpr: ppr_lcmd :: (OutputableBndrId id) => LHsCmd id -> SDoc
+ HsExpr: ppr_lcmd :: (SourceTextX p, OutputableBndrId p) => LHsCmd p -> SDoc
- HsExpr: ppr_lexpr :: (OutputableBndrId id) => LHsExpr id -> SDoc
+ HsExpr: ppr_lexpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc
- HsExpr: ppr_quasi :: OutputableBndr id => id -> id -> FastString -> SDoc
+ HsExpr: ppr_quasi :: OutputableBndr p => p -> p -> FastString -> SDoc
- HsExpr: ppr_splice :: (OutputableBndrId id) => SDoc -> id -> LHsExpr id -> SDoc -> SDoc
+ HsExpr: ppr_splice :: (SourceTextX p, OutputableBndrId p) => SDoc -> (IdP p) -> LHsExpr p -> SDoc -> SDoc
- HsExpr: ppr_splice_decl :: (OutputableBndrId id) => HsSplice id -> SDoc
+ HsExpr: ppr_splice_decl :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SDoc
- HsExpr: type CmdSyntaxTable id = [(Name, HsExpr id)]
+ HsExpr: type CmdSyntaxTable p = [(Name, HsExpr p)]
- HsExpr: type HsRecordBinds id = HsRecFields id (LHsExpr id)
+ HsExpr: type HsRecordBinds p = HsRecFields p (LHsExpr p)
- HsExpr: type LHsCmdTop id = Located (HsCmdTop id)
+ HsExpr: type LHsCmdTop p = Located (HsCmdTop p)
- HsExpr: type LHsExpr id = Located (HsExpr id) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
+ HsExpr: type LHsExpr p = Located (HsExpr p) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
- HsExpr: type PostTcExpr = HsExpr Id
+ HsExpr: type PostTcExpr = HsExpr GhcTc
- HsImpExp: IEThingAbs :: (LIEWrappedName name) -> IE name
+ HsImpExp: IEThingAbs :: (LIEWrappedName (IdP name)) -> IE name
- HsImpExp: IEThingAll :: (LIEWrappedName name) -> IE name
+ HsImpExp: IEThingAll :: (LIEWrappedName (IdP name)) -> IE name
- HsImpExp: IEThingWith :: (LIEWrappedName name) -> IEWildcard -> [LIEWrappedName name] -> [Located (FieldLbl name)] -> IE name
+ HsImpExp: IEThingWith :: (LIEWrappedName (IdP name)) -> IEWildcard -> [LIEWrappedName (IdP name)] -> [Located (FieldLbl (IdP name))] -> IE name
- HsImpExp: IEVar :: (LIEWrappedName name) -> IE name
+ HsImpExp: IEVar :: (LIEWrappedName (IdP name)) -> IE name
- HsImpExp: ieName :: IE name -> name
+ HsImpExp: ieName :: IE pass -> IdP pass
- HsImpExp: ieNames :: IE a -> [a]
+ HsImpExp: ieNames :: IE pass -> [IdP pass]
- HsLit: HsChar :: SourceText -> Char -> HsLit
+ HsLit: HsChar :: (XHsChar x) -> Char -> HsLit x
- HsLit: HsCharPrim :: SourceText -> Char -> HsLit
+ HsLit: HsCharPrim :: (XHsCharPrim x) -> Char -> HsLit x
- HsLit: HsDoublePrim :: FractionalLit -> HsLit
+ HsLit: HsDoublePrim :: (XHsDoublePrim x) -> FractionalLit -> HsLit x
- HsLit: HsFloatPrim :: FractionalLit -> HsLit
+ HsLit: HsFloatPrim :: (XHsFloatPrim x) -> FractionalLit -> HsLit x
- HsLit: HsInt :: SourceText -> Integer -> HsLit
+ HsLit: HsInt :: (XHsInt x) -> IntegralLit -> HsLit x
- HsLit: HsInt64Prim :: SourceText -> Integer -> HsLit
+ HsLit: HsInt64Prim :: (XHsInt64Prim x) -> Integer -> HsLit x
- HsLit: HsIntPrim :: SourceText -> Integer -> HsLit
+ HsLit: HsIntPrim :: (XHsIntPrim x) -> Integer -> HsLit x
- HsLit: HsInteger :: SourceText -> Integer -> Type -> HsLit
+ HsLit: HsInteger :: (XHsInteger x) -> Integer -> Type -> HsLit x
- HsLit: HsIntegral :: !SourceText -> !Integer -> OverLitVal
+ HsLit: HsIntegral :: !IntegralLit -> OverLitVal
- HsLit: HsRat :: FractionalLit -> Type -> HsLit
+ HsLit: HsRat :: (XHsRat x) -> FractionalLit -> Type -> HsLit x
- HsLit: HsString :: SourceText -> FastString -> HsLit
+ HsLit: HsString :: (XHsString x) -> FastString -> HsLit x
- HsLit: HsStringPrim :: SourceText -> ByteString -> HsLit
+ HsLit: HsStringPrim :: (XHsStringPrim x) -> ByteString -> HsLit x
- HsLit: HsWord64Prim :: SourceText -> Integer -> HsLit
+ HsLit: HsWord64Prim :: (XHsWord64Prim x) -> Integer -> HsLit x
- HsLit: HsWordPrim :: SourceText -> Integer -> HsLit
+ HsLit: HsWordPrim :: (XHsWordPrim x) -> Integer -> HsLit x
- HsLit: OverLit :: OverLitVal -> PostRn id Bool -> HsExpr id -> PostTc id Type -> HsOverLit id
+ HsLit: OverLit :: OverLitVal -> PostRn p Bool -> HsExpr p -> PostTc p Type -> HsOverLit p
- HsLit: [ol_rebindable] :: HsOverLit id -> PostRn id Bool
+ HsLit: [ol_rebindable] :: HsOverLit p -> PostRn p Bool
- HsLit: [ol_type] :: HsOverLit id -> PostTc id Type
+ HsLit: [ol_type] :: HsOverLit p -> PostTc p Type
- HsLit: [ol_val] :: HsOverLit id -> OverLitVal
+ HsLit: [ol_val] :: HsOverLit p -> OverLitVal
- HsLit: [ol_witness] :: HsOverLit id -> HsExpr id
+ HsLit: [ol_witness] :: HsOverLit p -> HsExpr p
- HsLit: data HsLit
+ HsLit: data HsLit x
- HsLit: data HsOverLit id
+ HsLit: data HsOverLit p
- HsLit: overLitType :: HsOverLit a -> PostTc a Type
+ HsLit: overLitType :: HsOverLit p -> PostTc p Type
- HsLit: pmPprHsLit :: HsLit -> SDoc
+ HsLit: pmPprHsLit :: (SourceTextX x) => HsLit x -> SDoc
- HsPat: AsPat :: (Located id) -> (LPat id) -> Pat id
+ HsPat: AsPat :: (Located (IdP p)) -> (LPat p) -> Pat p
- HsPat: BangPat :: (LPat id) -> Pat id
+ HsPat: BangPat :: (LPat p) -> Pat p
- HsPat: CoPat :: HsWrapper -> (Pat id) -> Type -> Pat id
+ HsPat: CoPat :: HsWrapper -> (Pat p) -> Type -> Pat p
- HsPat: ConPatIn :: (Located id) -> (HsConPatDetails id) -> Pat id
+ HsPat: ConPatIn :: (Located (IdP p)) -> (HsConPatDetails p) -> Pat p
- HsPat: ConPatOut :: Located ConLike -> [Type] -> [TyVar] -> [EvVar] -> TcEvBinds -> HsConPatDetails id -> HsWrapper -> Pat id
+ HsPat: ConPatOut :: Located ConLike -> [Type] -> [TyVar] -> [EvVar] -> TcEvBinds -> HsConPatDetails p -> HsWrapper -> Pat p
- HsPat: HsRecFields :: [LHsRecField id arg] -> Maybe Int -> HsRecFields id arg
+ HsPat: HsRecFields :: [LHsRecField p arg] -> Maybe Int -> HsRecFields p arg
- HsPat: LazyPat :: (LPat id) -> Pat id
+ HsPat: LazyPat :: (LPat p) -> Pat p
- HsPat: ListPat :: [LPat id] -> (PostTc id Type) -> (Maybe (PostTc id Type, SyntaxExpr id)) -> Pat id
+ HsPat: ListPat :: [LPat p] -> (PostTc p Type) -> (Maybe (PostTc p Type, SyntaxExpr p)) -> Pat p
- HsPat: LitPat :: HsLit -> Pat id
+ HsPat: LitPat :: (HsLit p) -> Pat p
- HsPat: NPat :: (Located (HsOverLit id)) -> (Maybe (SyntaxExpr id)) -> (SyntaxExpr id) -> (PostTc id Type) -> Pat id
+ HsPat: NPat :: (Located (HsOverLit p)) -> (Maybe (SyntaxExpr p)) -> (SyntaxExpr p) -> (PostTc p Type) -> Pat p
- HsPat: NPlusKPat :: (Located id) -> (Located (HsOverLit id)) -> (HsOverLit id) -> (SyntaxExpr id) -> (SyntaxExpr id) -> (PostTc id Type) -> Pat id
+ HsPat: NPlusKPat :: (Located (IdP p)) -> (Located (HsOverLit p)) -> (HsOverLit p) -> (SyntaxExpr p) -> (SyntaxExpr p) -> (PostTc p Type) -> Pat p
- HsPat: PArrPat :: [LPat id] -> (PostTc id Type) -> Pat id
+ HsPat: PArrPat :: [LPat p] -> (PostTc p Type) -> Pat p
- HsPat: ParPat :: (LPat id) -> Pat id
+ HsPat: ParPat :: (LPat p) -> Pat p
- HsPat: SigPatIn :: (LPat id) -> (LHsSigWcType id) -> Pat id
+ HsPat: SigPatIn :: (LPat p) -> (LHsSigWcType p) -> Pat p
- HsPat: SigPatOut :: (LPat id) -> Type -> Pat id
+ HsPat: SigPatOut :: (LPat p) -> Type -> Pat p
- HsPat: SplicePat :: (HsSplice id) -> Pat id
+ HsPat: SplicePat :: (HsSplice p) -> Pat p
- HsPat: SumPat :: (LPat id) -> ConTag -> Arity -> (PostTc id [Type]) -> Pat id
+ HsPat: SumPat :: (LPat p) -> ConTag -> Arity -> (PostTc p [Type]) -> Pat p
- HsPat: TuplePat :: [LPat id] -> Boxity -> [PostTc id Type] -> Pat id
+ HsPat: TuplePat :: [LPat p] -> Boxity -> [PostTc p Type] -> Pat p
- HsPat: VarPat :: (Located id) -> Pat id
+ HsPat: VarPat :: (Located (IdP p)) -> Pat p
- HsPat: ViewPat :: (LHsExpr id) -> (LPat id) -> (PostTc id Type) -> Pat id
+ HsPat: ViewPat :: (LHsExpr p) -> (LPat p) -> (PostTc p Type) -> Pat p
- HsPat: WildPat :: (PostTc id Type) -> Pat id
+ HsPat: WildPat :: (PostTc p Type) -> Pat p
- HsPat: [pat_arg_tys] :: Pat id -> [Type]
+ HsPat: [pat_arg_tys] :: Pat p -> [Type]
- HsPat: [pat_args] :: Pat id -> HsConPatDetails id
+ HsPat: [pat_args] :: Pat p -> HsConPatDetails p
- HsPat: [pat_binds] :: Pat id -> TcEvBinds
+ HsPat: [pat_binds] :: Pat p -> TcEvBinds
- HsPat: [pat_con] :: Pat id -> Located ConLike
+ HsPat: [pat_con] :: Pat p -> Located ConLike
- HsPat: [pat_dicts] :: Pat id -> [EvVar]
+ HsPat: [pat_dicts] :: Pat p -> [EvVar]
- HsPat: [pat_tvs] :: Pat id -> [TyVar]
+ HsPat: [pat_tvs] :: Pat p -> [TyVar]
- HsPat: [pat_wrap] :: Pat id -> HsWrapper
+ HsPat: [pat_wrap] :: Pat p -> HsWrapper
- HsPat: [rec_dotdot] :: HsRecFields id arg -> Maybe Int
+ HsPat: [rec_dotdot] :: HsRecFields p arg -> Maybe Int
- HsPat: [rec_flds] :: HsRecFields id arg -> [LHsRecField id arg]
+ HsPat: [rec_flds] :: HsRecFields p arg -> [LHsRecField p arg]
- HsPat: collectEvVarsPats :: [Pat id] -> Bag EvVar
+ HsPat: collectEvVarsPats :: [Pat p] -> Bag EvVar
- HsPat: data HsRecFields id arg
+ HsPat: data HsRecFields p arg
- HsPat: data Pat id
+ HsPat: data Pat p
- HsPat: hsConPatArgs :: HsConPatDetails id -> [LPat id]
+ HsPat: hsConPatArgs :: HsConPatDetails p -> [LPat p]
- HsPat: hsRecFieldId :: HsRecField Id arg -> Located Id
+ HsPat: hsRecFieldId :: HsRecField GhcTc arg -> Located Id
- HsPat: hsRecFieldSel :: HsRecField name arg -> Located (PostRn name name)
+ HsPat: hsRecFieldSel :: HsRecField pass arg -> Located (PostRn pass (IdP pass))
- HsPat: hsRecFields :: HsRecFields id arg -> [PostRn id id]
+ HsPat: hsRecFields :: HsRecFields p arg -> [PostRn p (IdP p)]
- HsPat: hsRecFieldsArgs :: HsRecFields id arg -> [arg]
+ HsPat: hsRecFieldsArgs :: HsRecFields p arg -> [arg]
- HsPat: hsRecUpdFieldId :: HsRecField' (AmbiguousFieldOcc Id) arg -> Located Id
+ HsPat: hsRecUpdFieldId :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> Located Id
- HsPat: hsRecUpdFieldOcc :: HsRecField' (AmbiguousFieldOcc Id) arg -> LFieldOcc Id
+ HsPat: hsRecUpdFieldOcc :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> LFieldOcc GhcTc
- HsPat: hsRecUpdFieldRdr :: HsRecUpdField id -> Located RdrName
+ HsPat: hsRecUpdFieldRdr :: HsRecUpdField p -> Located RdrName
- HsPat: isBangedLPat :: LPat id -> Bool
+ HsPat: isBangedLPat :: LPat p -> Bool
- HsPat: isIrrefutableHsPat :: (OutputableBndrId id) => LPat id -> Bool
+ HsPat: isIrrefutableHsPat :: (SourceTextX p, OutputableBndrId p) => LPat p -> Bool
- HsPat: looksLazyPatBind :: HsBind id -> Bool
+ HsPat: looksLazyPatBind :: HsBind p -> Bool
- HsPat: mkCharLitPat :: SourceText -> Char -> OutPat id
+ HsPat: mkCharLitPat :: (SourceTextX p) => SourceText -> Char -> OutPat p
- HsPat: mkNilPat :: Type -> OutPat id
+ HsPat: mkNilPat :: Type -> OutPat p
- HsPat: mkPrefixConPat :: DataCon -> [OutPat id] -> [Type] -> OutPat id
+ HsPat: mkPrefixConPat :: DataCon -> [OutPat p] -> [Type] -> OutPat p
- HsPat: pprConArgs :: (OutputableBndrId id) => HsConPatDetails id -> SDoc
+ HsPat: pprConArgs :: (SourceTextX p, OutputableBndrId p) => HsConPatDetails p -> SDoc
- HsPat: pprParendLPat :: (OutputableBndrId name) => LPat name -> SDoc
+ HsPat: pprParendLPat :: (SourceTextX pass, OutputableBndrId pass) => LPat pass -> SDoc
- HsPat: type HsConPatDetails id = HsConDetails (LPat id) (HsRecFields id (LPat id))
+ HsPat: type HsConPatDetails p = HsConDetails (LPat p) (HsRecFields p (LPat p))
- HsPat: type HsRecField id arg = HsRecField' (FieldOcc id) arg
+ HsPat: type HsRecField p arg = HsRecField' (FieldOcc p) arg
- HsPat: type HsRecUpdField id = HsRecField' (AmbiguousFieldOcc id) (LHsExpr id)
+ HsPat: type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p)
- HsPat: type InPat id = LPat id
+ HsPat: type InPat p = LPat p
- HsPat: type LHsRecField id arg = Located (HsRecField id arg)
+ HsPat: type LHsRecField p arg = Located (HsRecField p arg)
- HsPat: type LHsRecField' id arg = Located (HsRecField' id arg)
+ HsPat: type LHsRecField' p arg = Located (HsRecField' p arg)
- HsPat: type LHsRecUpdField id = Located (HsRecUpdField id)
+ HsPat: type LHsRecUpdField p = Located (HsRecUpdField p)
- HsPat: type LPat id = Located (Pat id)
+ HsPat: type LPat p = Located (Pat p)
- HsPat: type OutPat id = LPat id
+ HsPat: type OutPat p = LPat p
- HsTypes: Ambiguous :: (Located RdrName) -> (PostTc name name) -> AmbiguousFieldOcc name
+ HsTypes: Ambiguous :: (Located RdrName) -> (PostTc pass (IdP pass)) -> AmbiguousFieldOcc pass
- HsTypes: AnonWildCard :: (PostRn name (Located Name)) -> HsWildCardInfo name
+ HsTypes: AnonWildCard :: (PostRn pass (Located Name)) -> HsWildCardInfo pass
- HsTypes: ConDeclField :: [LFieldOcc name] -> LBangType name -> Maybe LHsDocString -> ConDeclField name
+ HsTypes: ConDeclField :: [LFieldOcc pass] -> LBangType pass -> Maybe LHsDocString -> ConDeclField pass
- HsTypes: FieldOcc :: Located RdrName -> PostRn name name -> FieldOcc name
+ HsTypes: FieldOcc :: Located RdrName -> PostRn pass (IdP pass) -> FieldOcc pass
- HsTypes: HsAppInfix :: (Located name) -> HsAppType name
+ HsTypes: HsAppInfix :: (Located (IdP pass)) -> HsAppType pass
- HsTypes: HsAppPrefix :: (LHsType name) -> HsAppType name
+ HsTypes: HsAppPrefix :: (LHsType pass) -> HsAppType pass
- HsTypes: HsAppTy :: (LHsType name) -> (LHsType name) -> HsType name
+ HsTypes: HsAppTy :: (LHsType pass) -> (LHsType pass) -> HsType pass
- HsTypes: HsAppsTy :: [LHsAppType name] -> HsType name
+ HsTypes: HsAppsTy :: [LHsAppType pass] -> HsType pass
- HsTypes: HsBangTy :: HsSrcBang -> (LHsType name) -> HsType name
+ HsTypes: HsBangTy :: HsSrcBang -> (LHsType pass) -> HsType pass
- HsTypes: HsCoreTy :: Type -> HsType name
+ HsTypes: HsCoreTy :: Type -> HsType pass
- HsTypes: HsDocTy :: (LHsType name) -> LHsDocString -> HsType name
+ HsTypes: HsDocTy :: (LHsType pass) -> LHsDocString -> HsType pass
- HsTypes: HsEqTy :: (LHsType name) -> (LHsType name) -> HsType name
+ HsTypes: HsEqTy :: (LHsType pass) -> (LHsType pass) -> HsType pass
- HsTypes: HsExplicitListTy :: Promoted -> (PostTc name Kind) -> [LHsType name] -> HsType name
+ HsTypes: HsExplicitListTy :: Promoted -> (PostTc pass Kind) -> [LHsType pass] -> HsType pass
- HsTypes: HsExplicitTupleTy :: [PostTc name Kind] -> [LHsType name] -> HsType name
+ HsTypes: HsExplicitTupleTy :: [PostTc pass Kind] -> [LHsType pass] -> HsType pass
- HsTypes: HsForAllTy :: [LHsTyVarBndr name] -> LHsType name -> HsType name
+ HsTypes: HsForAllTy :: [LHsTyVarBndr pass] -> LHsType pass -> HsType pass
- HsTypes: HsFunTy :: (LHsType name) -> (LHsType name) -> HsType name
+ HsTypes: HsFunTy :: (LHsType pass) -> (LHsType pass) -> HsType pass
- HsTypes: HsIB :: PostRn name [Name] -> thing -> PostRn name Bool -> HsImplicitBndrs name thing
+ HsTypes: HsIB :: PostRn pass [Name] -> thing -> PostRn pass Bool -> HsImplicitBndrs pass thing
- HsTypes: HsIParamTy :: (Located HsIPName) -> (LHsType name) -> HsType name
+ HsTypes: HsIParamTy :: (Located HsIPName) -> (LHsType pass) -> HsType pass
- HsTypes: HsKindSig :: (LHsType name) -> (LHsKind name) -> HsType name
+ HsTypes: HsKindSig :: (LHsType pass) -> (LHsKind pass) -> HsType pass
- HsTypes: HsListTy :: (LHsType name) -> HsType name
+ HsTypes: HsListTy :: (LHsType pass) -> HsType pass
- HsTypes: HsOpTy :: (LHsType name) -> (Located name) -> (LHsType name) -> HsType name
+ HsTypes: HsOpTy :: (LHsType pass) -> (Located (IdP pass)) -> (LHsType pass) -> HsType pass
- HsTypes: HsPArrTy :: (LHsType name) -> HsType name
+ HsTypes: HsPArrTy :: (LHsType pass) -> HsType pass
- HsTypes: HsParTy :: (LHsType name) -> HsType name
+ HsTypes: HsParTy :: (LHsType pass) -> HsType pass
- HsTypes: HsQTvs :: PostRn name [Name] -> [LHsTyVarBndr name] -> PostRn name NameSet -> LHsQTyVars name
+ HsTypes: HsQTvs :: PostRn pass [Name] -> [LHsTyVarBndr pass] -> PostRn pass NameSet -> LHsQTyVars pass
- HsTypes: HsQualTy :: LHsContext name -> LHsType name -> HsType name
+ HsTypes: HsQualTy :: LHsContext pass -> LHsType pass -> HsType pass
- HsTypes: HsRecTy :: [LConDeclField name] -> HsType name
+ HsTypes: HsRecTy :: [LConDeclField pass] -> HsType pass
- HsTypes: HsSpliceTy :: (HsSplice name) -> (PostTc name Kind) -> HsType name
+ HsTypes: HsSpliceTy :: (HsSplice pass) -> (PostTc pass Kind) -> HsType pass
- HsTypes: HsSumTy :: [LHsType name] -> HsType name
+ HsTypes: HsSumTy :: [LHsType pass] -> HsType pass
- HsTypes: HsTupleTy :: HsTupleSort -> [LHsType name] -> HsType name
+ HsTypes: HsTupleTy :: HsTupleSort -> [LHsType pass] -> HsType pass
- HsTypes: HsTyLit :: HsTyLit -> HsType name
+ HsTypes: HsTyLit :: HsTyLit -> HsType pass
- HsTypes: HsTyVar :: Promoted -> (Located name) -> HsType name
+ HsTypes: HsTyVar :: Promoted -> (Located (IdP pass)) -> HsType pass
- HsTypes: HsWC :: PostRn name [Name] -> thing -> HsWildCardBndrs name thing
+ HsTypes: HsWC :: PostRn pass [Name] -> thing -> HsWildCardBndrs pass thing
- HsTypes: HsWildCardTy :: (HsWildCardInfo name) -> HsType name
+ HsTypes: HsWildCardTy :: (HsWildCardInfo pass) -> HsType pass
- HsTypes: KindedTyVar :: (Located name) -> (LHsKind name) -> HsTyVarBndr name
+ HsTypes: KindedTyVar :: (Located (IdP pass)) -> (LHsKind pass) -> HsTyVarBndr pass
- HsTypes: Unambiguous :: (Located RdrName) -> (PostRn name name) -> AmbiguousFieldOcc name
+ HsTypes: Unambiguous :: (Located RdrName) -> (PostRn pass (IdP pass)) -> AmbiguousFieldOcc pass
- HsTypes: UserTyVar :: (Located name) -> HsTyVarBndr name
+ HsTypes: UserTyVar :: (Located (IdP pass)) -> HsTyVarBndr pass
- HsTypes: [cd_fld_doc] :: ConDeclField name -> Maybe LHsDocString
+ HsTypes: [cd_fld_doc] :: ConDeclField pass -> Maybe LHsDocString
- HsTypes: [cd_fld_names] :: ConDeclField name -> [LFieldOcc name]
+ HsTypes: [cd_fld_names] :: ConDeclField pass -> [LFieldOcc pass]
- HsTypes: [cd_fld_type] :: ConDeclField name -> LBangType name
+ HsTypes: [cd_fld_type] :: ConDeclField pass -> LBangType pass
- HsTypes: [hsib_body] :: HsImplicitBndrs name thing -> thing
+ HsTypes: [hsib_body] :: HsImplicitBndrs pass thing -> thing
- HsTypes: [hsib_closed] :: HsImplicitBndrs name thing -> PostRn name Bool
+ HsTypes: [hsib_closed] :: HsImplicitBndrs pass thing -> PostRn pass Bool
- HsTypes: [hsib_vars] :: HsImplicitBndrs name thing -> PostRn name [Name]
+ HsTypes: [hsib_vars] :: HsImplicitBndrs pass thing -> PostRn pass [Name]
- HsTypes: [hsq_dependent] :: LHsQTyVars name -> PostRn name NameSet
+ HsTypes: [hsq_dependent] :: LHsQTyVars pass -> PostRn pass NameSet
- HsTypes: [hsq_explicit] :: LHsQTyVars name -> [LHsTyVarBndr name]
+ HsTypes: [hsq_explicit] :: LHsQTyVars pass -> [LHsTyVarBndr pass]
- HsTypes: [hsq_implicit] :: LHsQTyVars name -> PostRn name [Name]
+ HsTypes: [hsq_implicit] :: LHsQTyVars pass -> PostRn pass [Name]
- HsTypes: [hst_bndrs] :: HsType name -> [LHsTyVarBndr name]
+ HsTypes: [hst_bndrs] :: HsType pass -> [LHsTyVarBndr pass]
- HsTypes: [hst_body] :: HsType name -> LHsType name
+ HsTypes: [hst_body] :: HsType pass -> LHsType pass
- HsTypes: [hst_ctxt] :: HsType name -> LHsContext name
+ HsTypes: [hst_ctxt] :: HsType pass -> LHsContext pass
- HsTypes: [hswc_body] :: HsWildCardBndrs name thing -> thing
+ HsTypes: [hswc_body] :: HsWildCardBndrs pass thing -> thing
- HsTypes: [hswc_wcs] :: HsWildCardBndrs name thing -> PostRn name [Name]
+ HsTypes: [hswc_wcs] :: HsWildCardBndrs pass thing -> PostRn pass [Name]
- HsTypes: [rdrNameFieldOcc] :: FieldOcc name -> Located RdrName
+ HsTypes: [rdrNameFieldOcc] :: FieldOcc pass -> Located RdrName
- HsTypes: [selectorFieldOcc] :: FieldOcc name -> PostRn name name
+ HsTypes: [selectorFieldOcc] :: FieldOcc pass -> PostRn pass (IdP pass)
- HsTypes: ambiguousFieldOcc :: FieldOcc name -> AmbiguousFieldOcc name
+ HsTypes: ambiguousFieldOcc :: FieldOcc pass -> AmbiguousFieldOcc pass
- HsTypes: data AmbiguousFieldOcc name
+ HsTypes: data AmbiguousFieldOcc pass
- HsTypes: data ConDeclField name
+ HsTypes: data ConDeclField pass
- HsTypes: data FieldOcc name
+ HsTypes: data FieldOcc pass
- HsTypes: data HsAppType name
+ HsTypes: data HsAppType pass
- HsTypes: data HsImplicitBndrs name thing
+ HsTypes: data HsImplicitBndrs pass thing
- HsTypes: data HsTyVarBndr name
+ HsTypes: data HsTyVarBndr pass
- HsTypes: data HsType name
+ HsTypes: data HsType pass
- HsTypes: data HsWildCardBndrs name thing
+ HsTypes: data HsWildCardBndrs pass thing
- HsTypes: data LHsQTyVars name
+ HsTypes: data LHsQTyVars pass
- HsTypes: dropWildCards :: LHsSigWcType name -> LHsSigType name
+ HsTypes: dropWildCards :: LHsSigWcType pass -> LHsSigType pass
- HsTypes: emptyLHsQTvs :: LHsQTyVars Name
+ HsTypes: emptyLHsQTvs :: LHsQTyVars GhcRn
- HsTypes: getAppsTyHead_maybe :: [LHsAppType name] -> Maybe (LHsType name, [LHsType name], LexicalFixity)
+ HsTypes: getAppsTyHead_maybe :: [LHsAppType pass] -> Maybe (LHsType pass, [LHsType pass], LexicalFixity)
- HsTypes: getLHsInstDeclClass_maybe :: LHsSigType name -> Maybe (Located name)
+ HsTypes: getLHsInstDeclClass_maybe :: LHsSigType pass -> Maybe (Located (IdP pass))
- HsTypes: getLHsInstDeclHead :: LHsSigType name -> LHsType name
+ HsTypes: getLHsInstDeclHead :: LHsSigType pass -> LHsType pass
- HsTypes: hsAllLTyVarNames :: LHsQTyVars Name -> [Name]
+ HsTypes: hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name]
- HsTypes: hsExplicitLTyVarNames :: LHsQTyVars name -> [name]
+ HsTypes: hsExplicitLTyVarNames :: LHsQTyVars pass -> [IdP pass]
- HsTypes: hsImplicitBody :: HsImplicitBndrs name thing -> thing
+ HsTypes: hsImplicitBody :: HsImplicitBndrs pass thing -> thing
- HsTypes: hsLTyVarBndrToType :: LHsTyVarBndr name -> LHsType name
+ HsTypes: hsLTyVarBndrToType :: LHsTyVarBndr pass -> LHsType pass
- HsTypes: hsLTyVarBndrsToTypes :: LHsQTyVars name -> [LHsType name]
+ HsTypes: hsLTyVarBndrsToTypes :: LHsQTyVars pass -> [LHsType pass]
- HsTypes: hsLTyVarLocName :: LHsTyVarBndr name -> Located name
+ HsTypes: hsLTyVarLocName :: LHsTyVarBndr pass -> Located (IdP pass)
- HsTypes: hsLTyVarLocNames :: LHsQTyVars name -> [Located name]
+ HsTypes: hsLTyVarLocNames :: LHsQTyVars pass -> [Located (IdP pass)]
- HsTypes: hsLTyVarName :: LHsTyVarBndr name -> name
+ HsTypes: hsLTyVarName :: LHsTyVarBndr pass -> IdP pass
- HsTypes: hsQTvExplicit :: LHsQTyVars name -> [LHsTyVarBndr name]
+ HsTypes: hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass]
- HsTypes: hsScopedTvs :: LHsSigType Name -> [Name]
+ HsTypes: hsScopedTvs :: LHsSigType GhcRn -> [Name]
- HsTypes: hsSigType :: LHsSigType name -> LHsType name
+ HsTypes: hsSigType :: LHsSigType pass -> LHsType pass
- HsTypes: hsSigWcType :: LHsSigWcType name -> LHsType name
+ HsTypes: hsSigWcType :: LHsSigWcType pass -> LHsType pass
- HsTypes: hsTvbAllKinded :: LHsQTyVars name -> Bool
+ HsTypes: hsTvbAllKinded :: LHsQTyVars pass -> Bool
- HsTypes: hsTyGetAppHead_maybe :: LHsType name -> Maybe (Located name, [LHsType name])
+ HsTypes: hsTyGetAppHead_maybe :: LHsType pass -> Maybe (Located (IdP pass), [LHsType pass])
- HsTypes: hsTyVarName :: HsTyVarBndr name -> name
+ HsTypes: hsTyVarName :: HsTyVarBndr pass -> IdP pass
- HsTypes: hsWcScopedTvs :: LHsSigWcType Name -> [Name]
+ HsTypes: hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name]
- HsTypes: ignoreParens :: LHsType name -> LHsType name
+ HsTypes: ignoreParens :: LHsType pass -> LHsType pass
- HsTypes: isEmptyLHsQTvs :: LHsQTyVars Name -> Bool
+ HsTypes: isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool
- HsTypes: isHsKindedTyVar :: HsTyVarBndr name -> Bool
+ HsTypes: isHsKindedTyVar :: HsTyVarBndr pass -> Bool
- HsTypes: mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc RdrName
+ HsTypes: mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs
- HsTypes: mkAnonWildCardTy :: HsType RdrName
+ HsTypes: mkAnonWildCardTy :: HsType GhcPs
- HsTypes: mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs Name thing
+ HsTypes: mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs GhcRn thing
- HsTypes: mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs Name thing
+ HsTypes: mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing
- HsTypes: mkFieldOcc :: Located RdrName -> FieldOcc RdrName
+ HsTypes: mkFieldOcc :: Located RdrName -> FieldOcc GhcPs
- HsTypes: mkHsAppTy :: LHsType name -> LHsType name -> LHsType name
+ HsTypes: mkHsAppTy :: LHsType pass -> LHsType pass -> LHsType pass
- HsTypes: mkHsAppTys :: LHsType name -> [LHsType name] -> LHsType name
+ HsTypes: mkHsAppTys :: LHsType pass -> [LHsType pass] -> LHsType pass
- HsTypes: mkHsImplicitBndrs :: thing -> HsImplicitBndrs RdrName thing
+ HsTypes: mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing
- HsTypes: mkHsOpTy :: LHsType name -> Located name -> LHsType name -> HsType name
+ HsTypes: mkHsOpTy :: LHsType pass -> Located (IdP pass) -> LHsType pass -> HsType pass
- HsTypes: mkHsQTvs :: [LHsTyVarBndr RdrName] -> LHsQTyVars RdrName
+ HsTypes: mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs
- HsTypes: mkHsWildCardBndrs :: thing -> HsWildCardBndrs RdrName thing
+ HsTypes: mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing
- HsTypes: newtype HsWildCardInfo name
+ HsTypes: newtype HsWildCardInfo pass
- HsTypes: pprConDeclFields :: (OutputableBndrId name) => [LConDeclField name] -> SDoc
+ HsTypes: pprConDeclFields :: (SourceTextX pass, OutputableBndrId pass) => [LConDeclField pass] -> SDoc
- HsTypes: pprHsContext :: (OutputableBndrId name) => HsContext name -> SDoc
+ HsTypes: pprHsContext :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> SDoc
- HsTypes: pprHsContextMaybe :: (OutputableBndrId name) => HsContext name -> Maybe SDoc
+ HsTypes: pprHsContextMaybe :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> Maybe SDoc
- HsTypes: pprHsContextNoArrow :: (OutputableBndrId name) => HsContext name -> SDoc
+ HsTypes: pprHsContextNoArrow :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> SDoc
- HsTypes: pprHsForAll :: (OutputableBndrId name) => [LHsTyVarBndr name] -> LHsContext name -> SDoc
+ HsTypes: pprHsForAll :: (SourceTextX pass, OutputableBndrId pass) => [LHsTyVarBndr pass] -> LHsContext pass -> SDoc
- HsTypes: pprHsForAllExtra :: (OutputableBndrId name) => Maybe SrcSpan -> [LHsTyVarBndr name] -> LHsContext name -> SDoc
+ HsTypes: pprHsForAllExtra :: (SourceTextX pass, OutputableBndrId pass) => Maybe SrcSpan -> [LHsTyVarBndr pass] -> LHsContext pass -> SDoc
- HsTypes: pprHsForAllTvs :: (OutputableBndrId name) => [LHsTyVarBndr name] -> SDoc
+ HsTypes: pprHsForAllTvs :: (SourceTextX pass, OutputableBndrId pass) => [LHsTyVarBndr pass] -> SDoc
- HsTypes: rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc name -> RdrName
+ HsTypes: rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc pass -> RdrName
- HsTypes: sameWildCard :: Located (HsWildCardInfo name) -> Located (HsWildCardInfo name) -> Bool
+ HsTypes: sameWildCard :: Located (HsWildCardInfo pass) -> Located (HsWildCardInfo pass) -> Bool
- HsTypes: selectorAmbiguousFieldOcc :: AmbiguousFieldOcc Id -> Id
+ HsTypes: selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id
- HsTypes: splitHsAppTys :: LHsType Name -> [LHsType Name] -> (LHsType Name, [LHsType Name])
+ HsTypes: splitHsAppTys :: LHsType GhcRn -> [LHsType GhcRn] -> (LHsType GhcRn, [LHsType GhcRn])
- HsTypes: splitHsAppsTy :: [LHsAppType name] -> ([[LHsType name]], [Located name])
+ HsTypes: splitHsAppsTy :: [LHsAppType pass] -> ([[LHsType pass]], [Located (IdP pass)])
- HsTypes: splitHsFunType :: LHsType Name -> ([LHsType Name], LHsType Name)
+ HsTypes: splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn)
- HsTypes: splitLHsForAllTy :: LHsType name -> ([LHsTyVarBndr name], LHsType name)
+ HsTypes: splitLHsForAllTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass)
- HsTypes: splitLHsInstDeclTy :: LHsSigType Name -> ([Name], LHsContext Name, LHsType Name)
+ HsTypes: splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn)
- HsTypes: splitLHsPatSynTy :: LHsType name -> ([LHsTyVarBndr name], LHsContext name, [LHsTyVarBndr name], LHsContext name, LHsType name)
+ HsTypes: splitLHsPatSynTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, [LHsTyVarBndr pass], LHsContext pass, LHsType pass)
- HsTypes: splitLHsQualTy :: LHsType name -> (LHsContext name, LHsType name)
+ HsTypes: splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass)
- HsTypes: splitLHsSigmaTy :: LHsType name -> ([LHsTyVarBndr name], LHsContext name, LHsType name)
+ HsTypes: splitLHsSigmaTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass)
- HsTypes: type BangType name = HsType name
+ HsTypes: type BangType pass = HsType pass
- HsTypes: type HsContext name = [LHsType name]
+ HsTypes: type HsContext pass = [LHsType pass]
- HsTypes: type HsKind name = HsType name
+ HsTypes: type HsKind pass = HsType pass
- HsTypes: type LBangType name = Located (BangType name)
+ HsTypes: type LBangType pass = Located (BangType pass)
- HsTypes: type LConDeclField name = Located (ConDeclField name) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
+ HsTypes: type LConDeclField pass = Located (ConDeclField pass) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
- HsTypes: type LFieldOcc name = Located (FieldOcc name)
+ HsTypes: type LFieldOcc pass = Located (FieldOcc pass)
- HsTypes: type LHsAppType name = Located (HsAppType name) 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSimpleQuote'
+ HsTypes: type LHsAppType pass = Located (HsAppType pass) 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSimpleQuote'
- HsTypes: type LHsContext name = Located (HsContext name) 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnUnit'
+ HsTypes: type LHsContext pass = Located (HsContext pass) 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnUnit'
- HsTypes: type LHsKind name = Located (HsKind name) 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon'
+ HsTypes: type LHsKind pass = Located (HsKind pass) 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon'
- HsTypes: type LHsSigType name = HsImplicitBndrs name (LHsType name)
+ HsTypes: type LHsSigType pass = HsImplicitBndrs pass (LHsType pass)
- HsTypes: type LHsSigWcType name = HsWildCardBndrs name (LHsSigType name)
+ HsTypes: type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass)
- HsTypes: type LHsTyVarBndr name = Located (HsTyVarBndr name)
+ HsTypes: type LHsTyVarBndr pass = Located (HsTyVarBndr pass)
- HsTypes: type LHsType name = Located (HsType name) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
+ HsTypes: type LHsType pass = Located (HsType pass) May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when in a list
- HsTypes: type LHsWcType name = HsWildCardBndrs name (LHsType name)
+ HsTypes: type LHsWcType pass = HsWildCardBndrs pass (LHsType pass)
- HsTypes: unambiguousFieldOcc :: AmbiguousFieldOcc Id -> FieldOcc Id
+ HsTypes: unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc
- HsTypes: updateGadtResult :: (Monad m) => (SDoc -> m ()) -> SDoc -> HsConDetails (LHsType Name) (Located [LConDeclField Name]) -> LHsType Name -> m (HsConDetails (LHsType Name) (Located [LConDeclField Name]), LHsType Name)
+ HsTypes: updateGadtResult :: (Monad m) => (SDoc -> m ()) -> SDoc -> HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]) -> LHsType GhcRn -> m (HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]), LHsType GhcRn)
- HsTypes: wildCardName :: HsWildCardInfo Name -> Name
+ HsTypes: wildCardName :: HsWildCardInfo GhcRn -> Name
- HsUtils: collectHsBindBinders :: HsBindLR idL idR -> [idL]
+ HsUtils: collectHsBindBinders :: HsBindLR idL idR -> [IdP idL]
- HsUtils: collectHsBindListBinders :: [LHsBindLR idL idR] -> [idL]
+ HsUtils: collectHsBindListBinders :: [LHsBindLR idL idR] -> [IdP idL]
- HsUtils: collectHsBindsBinders :: LHsBindsLR idL idR -> [idL]
+ HsUtils: collectHsBindsBinders :: LHsBindsLR idL idR -> [IdP idL]
- HsUtils: collectHsIdBinders :: HsValBindsLR idL idR -> [idL]
+ HsUtils: collectHsIdBinders :: HsValBindsLR idL idR -> [IdP idL]
- HsUtils: collectHsValBinders :: HsValBindsLR idL idR -> [idL]
+ HsUtils: collectHsValBinders :: HsValBindsLR idL idR -> [IdP idL]
- HsUtils: collectLStmtBinders :: LStmtLR idL idR body -> [idL]
+ HsUtils: collectLStmtBinders :: LStmtLR idL idR body -> [IdP idL]
- HsUtils: collectLStmtsBinders :: [LStmtLR idL idR body] -> [idL]
+ HsUtils: collectLStmtsBinders :: [LStmtLR idL idR body] -> [IdP idL]
- HsUtils: collectLocalBinders :: HsLocalBindsLR idL idR -> [idL]
+ HsUtils: collectLocalBinders :: HsLocalBindsLR idL idR -> [IdP idL]
- HsUtils: collectMethodBinders :: LHsBindsLR RdrName idR -> [Located RdrName]
+ HsUtils: collectMethodBinders :: LHsBindsLR GhcPs idR -> [Located RdrName]
- HsUtils: collectPatBinders :: LPat a -> [a]
+ HsUtils: collectPatBinders :: LPat a -> [IdP a]
- HsUtils: collectPatsBinders :: [LPat a] -> [a]
+ HsUtils: collectPatsBinders :: [LPat a] -> [IdP a]
- HsUtils: collectStmtBinders :: StmtLR idL idR body -> [idL]
+ HsUtils: collectStmtBinders :: StmtLR idL idR body -> [IdP idL]
- HsUtils: collectStmtsBinders :: [StmtLR idL idR body] -> [idL]
+ HsUtils: collectStmtsBinders :: [StmtLR idL idR body] -> [IdP idL]
- HsUtils: emptyRecStmt :: StmtLR idL RdrName bodyR
+ HsUtils: emptyRecStmt :: StmtLR idL GhcPs bodyR
- HsUtils: emptyRecStmtId :: StmtLR Id Id bodyR
+ HsUtils: emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR
- HsUtils: emptyRecStmtName :: StmtLR Name Name bodyR
+ HsUtils: emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR
- HsUtils: emptyTransStmt :: (PostTc idR Type ~ PlaceHolder) => StmtLR idL idR (LHsExpr idR)
+ HsUtils: emptyTransStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => StmtLR idL idR (LHsExpr idR)
- HsUtils: hsDataDefnBinders :: HsDataDefn name -> ([Located name], [LFieldOcc name])
+ HsUtils: hsDataDefnBinders :: HsDataDefn pass -> ([Located (IdP pass)], [LFieldOcc pass])
- HsUtils: hsDataFamInstBinders :: DataFamInstDecl name -> ([Located name], [LFieldOcc name])
+ HsUtils: hsDataFamInstBinders :: DataFamInstDecl pass -> ([Located (IdP pass)], [LFieldOcc pass])
- HsUtils: hsForeignDeclsBinders :: [LForeignDecl name] -> [Located name]
+ HsUtils: hsForeignDeclsBinders :: [LForeignDecl pass] -> [Located (IdP pass)]
- HsUtils: hsGroupBinders :: HsGroup Name -> [Name]
+ HsUtils: hsGroupBinders :: HsGroup GhcRn -> [Name]
- HsUtils: hsLTyClDeclBinders :: Located (TyClDecl name) -> ([Located name], [LFieldOcc name])
+ HsUtils: hsLTyClDeclBinders :: Located (TyClDecl pass) -> ([Located (IdP pass)], [LFieldOcc pass])
- HsUtils: hsPatSynSelectors :: HsValBinds id -> [id]
+ HsUtils: hsPatSynSelectors :: HsValBinds p -> [IdP p]
- HsUtils: hsTyClForeignBinders :: [TyClGroup Name] -> [LForeignDecl Name] -> [Name]
+ HsUtils: hsTyClForeignBinders :: [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name]
- HsUtils: hsValBindsImplicits :: HsValBindsLR Name idR -> NameSet
+ HsUtils: hsValBindsImplicits :: HsValBindsLR GhcRn idR -> NameSet
- HsUtils: isUnliftedHsBind :: HsBind Id -> Bool
+ HsUtils: isUnliftedHsBind :: HsBind GhcTc -> Bool
- HsUtils: lPatImplicits :: LPat Name -> NameSet
+ HsUtils: lPatImplicits :: LPat GhcRn -> NameSet
- HsUtils: lStmtsImplicits :: [LStmtLR Name idR (Located (body idR))] -> NameSet
+ HsUtils: lStmtsImplicits :: [LStmtLR GhcRn idR (Located (body idR))] -> NameSet
- HsUtils: missingTupArg :: HsTupArg RdrName
+ HsUtils: missingTupArg :: HsTupArg GhcPs
- HsUtils: mkBigLHsVarPatTup :: [id] -> LPat id
+ HsUtils: mkBigLHsVarPatTup :: [IdP id] -> LPat id
- HsUtils: mkBigLHsVarTup :: [id] -> LHsExpr id
+ HsUtils: mkBigLHsVarTup :: [IdP id] -> LHsExpr id
- HsUtils: mkBindStmt :: (PostTc idR Type ~ PlaceHolder) => LPat idL -> Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))
+ HsUtils: mkBindStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => LPat idL -> Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))
- HsUtils: mkBodyStmt :: Located (bodyR RdrName) -> StmtLR idL RdrName (Located (bodyR RdrName))
+ HsUtils: mkBodyStmt :: Located (bodyR GhcPs) -> StmtLR idL GhcPs (Located (bodyR GhcPs))
- HsUtils: mkClassOpSigs :: [LSig RdrName] -> [LSig RdrName]
+ HsUtils: mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs]
- HsUtils: mkFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> HsBind RdrName
+ HsUtils: mkFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> HsBind GhcPs
- HsUtils: mkGroupByUsingStmt :: (PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
+ HsUtils: mkGroupByUsingStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
- HsUtils: mkGroupUsingStmt :: (PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
+ HsUtils: mkGroupUsingStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
- HsUtils: mkHsAppTy :: LHsType name -> LHsType name -> LHsType name
+ HsUtils: mkHsAppTy :: LHsType pass -> LHsType pass -> LHsType pass
- HsUtils: mkHsAppTypeOut :: LHsExpr Id -> LHsWcType Name -> LHsExpr Id
+ HsUtils: mkHsAppTypeOut :: LHsExpr GhcTc -> LHsWcType GhcRn -> LHsExpr GhcTc
- HsUtils: mkHsAppTys :: LHsType name -> [LHsType name] -> LHsType name
+ HsUtils: mkHsAppTys :: LHsType pass -> [LHsType pass] -> LHsType pass
- HsUtils: mkHsComp :: HsStmtContext Name -> [ExprLStmt RdrName] -> LHsExpr RdrName -> HsExpr RdrName
+ HsUtils: mkHsComp :: HsStmtContext Name -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> HsExpr GhcPs
- HsUtils: mkHsDictLet :: TcEvBinds -> LHsExpr Id -> LHsExpr Id
+ HsUtils: mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc
- HsUtils: mkHsDo :: HsStmtContext Name -> [ExprLStmt RdrName] -> HsExpr RdrName
+ HsUtils: mkHsDo :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs
- HsUtils: mkHsFractional :: FractionalLit -> PostTc RdrName Type -> HsOverLit RdrName
+ HsUtils: mkHsFractional :: FractionalLit -> PostTc GhcPs Type -> HsOverLit GhcPs
- HsUtils: mkHsIf :: LHsExpr id -> LHsExpr id -> LHsExpr id -> HsExpr id
+ HsUtils: mkHsIf :: SourceTextX p => LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p
- HsUtils: mkHsIntegral :: SourceText -> Integer -> PostTc RdrName Type -> HsOverLit RdrName
+ HsUtils: mkHsIntegral :: IntegralLit -> PostTc GhcPs Type -> HsOverLit GhcPs
- HsUtils: mkHsIsString :: SourceText -> FastString -> PostTc RdrName Type -> HsOverLit RdrName
+ HsUtils: mkHsIsString :: SourceText -> FastString -> PostTc GhcPs Type -> HsOverLit GhcPs
- HsUtils: mkHsLam :: [LPat RdrName] -> LHsExpr RdrName -> LHsExpr RdrName
+ HsUtils: mkHsLam :: [LPat GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs
- HsUtils: mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr Id -> LHsExpr Id
+ HsUtils: mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr GhcTc -> LHsExpr GhcTc
- HsUtils: mkHsOpApp :: LHsExpr id -> id -> LHsExpr id -> HsExpr id
+ HsUtils: mkHsOpApp :: LHsExpr id -> IdP id -> LHsExpr id -> HsExpr id
- HsUtils: mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice RdrName
+ HsUtils: mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice GhcPs
- HsUtils: mkHsSigEnv :: forall a. (LSig Name -> Maybe ([Located Name], a)) -> [LSig Name] -> NameEnv a
+ HsUtils: mkHsSigEnv :: forall a. (LSig GhcRn -> Maybe ([Located Name], a)) -> [LSig GhcRn] -> NameEnv a
- HsUtils: mkHsSpliceE :: SpliceDecoration -> LHsExpr RdrName -> HsExpr RdrName
+ HsUtils: mkHsSpliceE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs
- HsUtils: mkHsSpliceTE :: SpliceDecoration -> LHsExpr RdrName -> HsExpr RdrName
+ HsUtils: mkHsSpliceTE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs
- HsUtils: mkHsSpliceTy :: SpliceDecoration -> LHsExpr RdrName -> HsType RdrName
+ HsUtils: mkHsSpliceTy :: SpliceDecoration -> LHsExpr GhcPs -> HsType GhcPs
- HsUtils: mkHsString :: String -> HsLit
+ HsUtils: mkHsString :: SourceTextX p => String -> HsLit p
- HsUtils: mkHsStringPrimLit :: FastString -> HsLit
+ HsUtils: mkHsStringPrimLit :: SourceTextX p => FastString -> HsLit p
- HsUtils: mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr RdrName -> LHsBind RdrName
+ HsUtils: mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr GhcPs -> LHsBind GhcPs
- HsUtils: mkLHsSigType :: LHsType RdrName -> LHsSigType RdrName
+ HsUtils: mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs
- HsUtils: mkLHsSigWcType :: LHsType RdrName -> LHsSigWcType RdrName
+ HsUtils: mkLHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs
- HsUtils: mkLHsVarTuple :: [a] -> LHsExpr a
+ HsUtils: mkLHsVarTuple :: [IdP a] -> LHsExpr a
- HsUtils: mkLastStmt :: Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))
+ HsUtils: mkLastStmt :: SourceTextX idR => Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))
- HsUtils: mkMatch :: HsMatchContext (NameOrRdrName id) -> [LPat id] -> LHsExpr id -> Located (HsLocalBinds id) -> LMatch id (LHsExpr id)
+ HsUtils: mkMatch :: HsMatchContext (NameOrRdrName (IdP p)) -> [LPat p] -> LHsExpr p -> Located (HsLocalBinds p) -> LMatch p (LHsExpr p)
- HsUtils: mkNPat :: Located (HsOverLit RdrName) -> Maybe (SyntaxExpr RdrName) -> Pat RdrName
+ HsUtils: mkNPat :: Located (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs) -> Pat GhcPs
- HsUtils: mkNPlusKPat :: Located RdrName -> Located (HsOverLit RdrName) -> Pat RdrName
+ HsUtils: mkNPlusKPat :: Located RdrName -> Located (HsOverLit GhcPs) -> Pat GhcPs
- HsUtils: mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName) -> LPat RdrName -> HsPatSynDir RdrName -> HsBind RdrName
+ HsUtils: mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName) -> LPat GhcPs -> HsPatSynDir GhcPs -> HsBind GhcPs
- HsUtils: mkRecStmt :: [LStmtLR idL RdrName bodyR] -> StmtLR idL RdrName bodyR
+ HsUtils: mkRecStmt :: [LStmtLR idL GhcPs bodyR] -> StmtLR idL GhcPs bodyR
- HsUtils: mkSimpleMatch :: HsMatchContext (NameOrRdrName id) -> [LPat id] -> Located (body id) -> LMatch id (Located (body id))
+ HsUtils: mkSimpleMatch :: HsMatchContext (NameOrRdrName (IdP id)) -> [LPat id] -> Located (body id) -> LMatch id (Located (body id))
- HsUtils: mkTcBindStmt :: LPat Id -> Located (bodyR Id) -> StmtLR Id Id (Located (bodyR Id))
+ HsUtils: mkTcBindStmt :: LPat GhcTc -> Located (bodyR GhcTc) -> StmtLR GhcTc GhcTc (Located (bodyR GhcTc))
- HsUtils: mkTopFunBind :: Origin -> Located Name -> [LMatch Name (LHsExpr Name)] -> HsBind Name
+ HsUtils: mkTopFunBind :: Origin -> Located Name -> [LMatch GhcRn (LHsExpr GhcRn)] -> HsBind GhcRn
- HsUtils: mkTransformByStmt :: (PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
+ HsUtils: mkTransformByStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
- HsUtils: mkTransformStmt :: (PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
+ HsUtils: mkTransformStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)
- HsUtils: mkUntypedSplice :: SpliceDecoration -> LHsExpr RdrName -> HsSplice RdrName
+ HsUtils: mkUntypedSplice :: SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs
- HsUtils: mkVarBind :: id -> LHsExpr id -> LHsBind id
+ HsUtils: mkVarBind :: IdP p -> LHsExpr p -> LHsBind p
- HsUtils: mk_easy_FunBind :: SrcSpan -> RdrName -> [LPat RdrName] -> LHsExpr RdrName -> LHsBind RdrName
+ HsUtils: mk_easy_FunBind :: SrcSpan -> RdrName -> [LPat GhcPs] -> LHsExpr GhcPs -> LHsBind GhcPs
- HsUtils: nlConPat :: RdrName -> [LPat RdrName] -> LPat RdrName
+ HsUtils: nlConPat :: RdrName -> [LPat GhcPs] -> LPat GhcPs
- HsUtils: nlConPatName :: Name -> [LPat Name] -> LPat Name
+ HsUtils: nlConPatName :: Name -> [LPat GhcRn] -> LPat GhcRn
- HsUtils: nlConVarPat :: RdrName -> [RdrName] -> LPat RdrName
+ HsUtils: nlConVarPat :: RdrName -> [RdrName] -> LPat GhcPs
- HsUtils: nlConVarPatName :: Name -> [Name] -> LPat Name
+ HsUtils: nlConVarPatName :: Name -> [Name] -> LPat GhcRn
- HsUtils: nlHsApps :: id -> [LHsExpr id] -> LHsExpr id
+ HsUtils: nlHsApps :: IdP id -> [LHsExpr id] -> LHsExpr id
- HsUtils: nlHsCase :: LHsExpr RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> LHsExpr RdrName
+ HsUtils: nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs
- HsUtils: nlHsDataCon :: DataCon -> LHsExpr Id
+ HsUtils: nlHsDataCon :: DataCon -> LHsExpr GhcTc
- HsUtils: nlHsDo :: HsStmtContext Name -> [LStmt RdrName (LHsExpr RdrName)] -> LHsExpr RdrName
+ HsUtils: nlHsDo :: HsStmtContext Name -> [LStmt GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs
- HsUtils: nlHsIntLit :: Integer -> LHsExpr id
+ HsUtils: nlHsIntLit :: HasDefaultX p => Integer -> LHsExpr p
- HsUtils: nlHsLam :: LMatch RdrName (LHsExpr RdrName) -> LHsExpr RdrName
+ HsUtils: nlHsLam :: LMatch GhcPs (LHsExpr GhcPs) -> LHsExpr GhcPs
- HsUtils: nlHsLit :: HsLit -> LHsExpr id
+ HsUtils: nlHsLit :: HsLit p -> LHsExpr p
- HsUtils: nlHsOpApp :: LHsExpr id -> id -> LHsExpr id -> LHsExpr id
+ HsUtils: nlHsOpApp :: LHsExpr id -> IdP id -> LHsExpr id -> LHsExpr id
- HsUtils: nlHsTyApp :: name -> [Type] -> LHsExpr name
+ HsUtils: nlHsTyApp :: IdP name -> [Type] -> LHsExpr name
- HsUtils: nlHsTyApps :: name -> [Type] -> [LHsExpr name] -> LHsExpr name
+ HsUtils: nlHsTyApps :: IdP name -> [Type] -> [LHsExpr name] -> LHsExpr name
- HsUtils: nlHsTyConApp :: name -> [LHsType name] -> LHsType name
+ HsUtils: nlHsTyConApp :: IdP name -> [LHsType name] -> LHsType name
- HsUtils: nlHsTyVar :: name -> LHsType name
+ HsUtils: nlHsTyVar :: IdP name -> LHsType name
- HsUtils: nlHsVar :: id -> LHsExpr id
+ HsUtils: nlHsVar :: IdP id -> LHsExpr id
- HsUtils: nlHsVarApps :: id -> [id] -> LHsExpr id
+ HsUtils: nlHsVarApps :: IdP id -> [IdP id] -> LHsExpr id
- HsUtils: nlInfixConPat :: id -> LPat id -> LPat id -> LPat id
+ HsUtils: nlInfixConPat :: IdP id -> LPat id -> LPat id -> LPat id
- HsUtils: nlList :: [LHsExpr RdrName] -> LHsExpr RdrName
+ HsUtils: nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs
- HsUtils: nlLitPat :: HsLit -> LPat id
+ HsUtils: nlLitPat :: HsLit p -> LPat p
- HsUtils: nlNullaryConPat :: id -> LPat id
+ HsUtils: nlNullaryConPat :: IdP id -> LPat id
- HsUtils: nlVarPat :: id -> LPat id
+ HsUtils: nlVarPat :: IdP id -> LPat id
- HsUtils: nlWildConPat :: DataCon -> LPat RdrName
+ HsUtils: nlWildConPat :: DataCon -> LPat GhcPs
- HsUtils: nlWildPat :: LPat RdrName
+ HsUtils: nlWildPat :: LPat GhcPs
- HsUtils: nlWildPatId :: LPat Id
+ HsUtils: nlWildPatId :: LPat GhcTc
- HsUtils: nlWildPatName :: LPat Name
+ HsUtils: nlWildPatName :: LPat GhcRn
- HsUtils: typeToLHsType :: Type -> LHsType RdrName
+ HsUtils: typeToLHsType :: Type -> LHsType GhcPs
- HsUtils: userHsLTyVarBndrs :: SrcSpan -> [Located name] -> [LHsTyVarBndr name]
+ HsUtils: userHsLTyVarBndrs :: SrcSpan -> [Located (IdP name)] -> [LHsTyVarBndr name]
- HsUtils: userHsTyVarBndrs :: SrcSpan -> [name] -> [LHsTyVarBndr name]
+ HsUtils: userHsTyVarBndrs :: SrcSpan -> [IdP name] -> [LHsTyVarBndr name]
- HscMain: hscImport :: HscEnv -> String -> IO (ImportDecl RdrName)
+ HscMain: hscImport :: HscEnv -> String -> IO (ImportDecl GhcPs)
- HscMain: hscParseExpr :: String -> Hsc (LHsExpr RdrName)
+ HscMain: hscParseExpr :: String -> Hsc (LHsExpr GhcPs)
- HscMain: hscParsedStmt :: HscEnv -> GhciLStmt RdrName -> IO (Maybe ([Id], ForeignHValue, FixityEnv))
+ HscMain: hscParsedStmt :: HscEnv -> GhciLStmt GhcPs -> IO (Maybe ([Id], ForeignHValue, FixityEnv))
- HscMain: hscRnImportDecls :: HscEnv -> [LImportDecl RdrName] -> IO GlobalRdrEnv
+ HscMain: hscRnImportDecls :: HscEnv -> [LImportDecl GhcPs] -> IO GlobalRdrEnv
- HscMain: hscSimplify :: HscEnv -> ModGuts -> IO ModGuts
+ HscMain: hscSimplify :: HscEnv -> [String] -> ModGuts -> IO ModGuts
- HscMain: hscSimplify' :: ModGuts -> Hsc ModGuts
+ HscMain: hscSimplify' :: [String] -> ModGuts -> Hsc ModGuts
- HscMain: hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
+ HscMain: hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))
- HscMain: tcRnModule' :: HscEnv -> ModSummary -> Bool -> HsParsedModule -> Hsc TcGblEnv
+ HscMain: tcRnModule' :: ModSummary -> Bool -> HsParsedModule -> Hsc TcGblEnv
- HscStats: ppSourceStats :: Bool -> Located (HsModule RdrName) -> SDoc
+ HscStats: ppSourceStats :: Bool -> Located (HsModule GhcPs) -> SDoc
- HscTypes: HsParsedModule :: Located (HsModule RdrName) -> [FilePath] -> ApiAnns -> HsParsedModule
+ HscTypes: HsParsedModule :: Located (HsModule GhcPs) -> [FilePath] -> ApiAnns -> HsParsedModule
- HscTypes: IIDecl :: (ImportDecl RdrName) -> InteractiveImport
+ HscTypes: IIDecl :: (ImportDecl GhcPs) -> InteractiveImport
- HscTypes: MetaD :: ([LHsDecl RdrName] -> MetaResult) -> MetaRequest
+ HscTypes: MetaD :: ([LHsDecl GhcPs] -> MetaResult) -> MetaRequest
- HscTypes: MetaE :: (LHsExpr RdrName -> MetaResult) -> MetaRequest
+ HscTypes: MetaE :: (LHsExpr GhcPs -> MetaResult) -> MetaRequest
- HscTypes: MetaP :: (LPat RdrName -> MetaResult) -> MetaRequest
+ HscTypes: MetaP :: (LPat GhcPs -> MetaResult) -> MetaRequest
- HscTypes: MetaT :: (LHsType RdrName -> MetaResult) -> MetaRequest
+ HscTypes: MetaT :: (LHsType GhcPs -> MetaResult) -> MetaRequest
- HscTypes: ModIface :: !Module -> !(Maybe Module) -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !HscSource -> Dependencies -> [Usage] -> ![IfaceExport] -> !Fingerprint -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [(Fingerprint, IfaceDecl)] -> !(Maybe GlobalRdrEnv) -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !Fingerprint -> !IfaceVectInfo -> (OccName -> Maybe WarningTxt) -> (OccName -> Maybe Fixity) -> (OccName -> Maybe (OccName, Fingerprint)) -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> [IfaceCompleteMatch] -> ModIface
+ HscTypes: ModIface :: !Module -> !(Maybe Module) -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !HscSource -> Dependencies -> [Usage] -> ![IfaceExport] -> !Fingerprint -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [(Fingerprint, IfaceDecl)] -> !(Maybe GlobalRdrEnv) -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !Fingerprint -> !IfaceVectInfo -> OccName -> Maybe WarningTxt -> OccName -> Maybe Fixity -> OccName -> Maybe (OccName, Fingerprint) -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> [IfaceCompleteMatch] -> ModIface
- HscTypes: [hpm_module] :: HsParsedModule -> Located (HsModule RdrName)
+ HscTypes: [hpm_module] :: HsParsedModule -> Located (HsModule GhcPs)
- HscTypes: data ForeignSrcLang :: *
+ HscTypes: data ForeignSrcLang
- HscTypes: handleFlagWarnings :: DynFlags -> [Located String] -> IO ()
+ HscTypes: handleFlagWarnings :: DynFlags -> [Warn] -> IO ()
- HscTypes: metaRequestAW :: Functor f => MetaHook f -> LHsExpr Id -> f Serialized
+ HscTypes: metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized
- HscTypes: metaRequestD :: Functor f => MetaHook f -> LHsExpr Id -> f [LHsDecl RdrName]
+ HscTypes: metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]
- HscTypes: metaRequestE :: Functor f => MetaHook f -> LHsExpr Id -> f (LHsExpr RdrName)
+ HscTypes: metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)
- HscTypes: metaRequestP :: Functor f => MetaHook f -> LHsExpr Id -> f (LPat RdrName)
+ HscTypes: metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)
- HscTypes: metaRequestT :: Functor f => MetaHook f -> LHsExpr Id -> f (LHsType RdrName)
+ HscTypes: metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)
- HscTypes: type MetaHook f = MetaRequest -> LHsExpr Id -> f MetaResult
+ HscTypes: type MetaHook f = MetaRequest -> LHsExpr GhcTc -> f MetaResult
- IOEnv: data IORef a :: * -> *
+ IOEnv: data IORef a
- IfaceEnv: NCU :: (forall c. (NameCache -> (NameCache, c)) -> IO c) -> NameCacheUpdater
+ IfaceEnv: NCU :: forall c. (NameCache -> (NameCache, c)) -> IO c -> NameCacheUpdater
- IfaceSyn: IfCon :: IfaceTopBndr -> Bool -> Bool -> [IfaceForAllBndr] -> IfaceEqSpec -> IfaceContext -> [IfaceType] -> [FieldLabel] -> [IfaceBang] -> [IfaceSrcBang] -> IfaceConDecl
+ IfaceSyn: IfCon :: IfaceTopBndr -> Bool -> Bool -> [IfaceTvBndr] -> [IfaceForAllBndr] -> IfaceEqSpec -> IfaceContext -> [IfaceType] -> [FieldLabel] -> [IfaceBang] -> [IfaceSrcBang] -> IfaceConDecl
- IfaceSyn: [ifConExTvs] :: IfaceConDecl -> [IfaceForAllBndr]
+ IfaceSyn: [ifConExTvs] :: IfaceConDecl -> [IfaceTvBndr]
- IfaceType: IfaceEqualityTyCon :: !Bool -> IfaceTyConSort
+ IfaceType: IfaceEqualityTyCon :: IfaceTyConSort
- IfaceType: mkIfaceTySubst :: [IfaceTvBndr] -> [IfaceType] -> IfaceTySubst
+ IfaceType: mkIfaceTySubst :: [(IfLclName, IfaceType)] -> IfaceTySubst
- IfaceType: pprIfaceContext :: [IfacePredType] -> SDoc
+ IfaceType: pprIfaceContext :: TyPrec -> [IfacePredType] -> SDoc
- Inst: mkOverLit :: OverLitVal -> TcM HsLit
+ Inst: mkOverLit :: (HasDefaultX p, SourceTextX p) => OverLitVal -> TcM (HsLit p)
- Inst: newMethodFromName :: CtOrigin -> Name -> TcRhoType -> TcM (HsExpr TcId)
+ Inst: newMethodFromName :: CtOrigin -> Name -> TcRhoType -> TcM (HsExpr GhcTcId)
- Inst: newOverloadedLit :: HsOverLit Name -> ExpRhoType -> TcM (HsOverLit TcId)
+ Inst: newOverloadedLit :: HsOverLit GhcRn -> ExpRhoType -> TcM (HsOverLit GhcTcId)
- Inst: tcInstBinders :: [TyBinder] -> TcM (TCvSubst, [TcType])
+ Inst: tcInstBinders :: TCvSubst -> Maybe (VarEnv Kind) -> [TyBinder] -> TcM (TCvSubst, [TcType])
- Inst: tcSyntaxName :: CtOrigin -> TcType -> (Name, HsExpr Name) -> TcM (Name, HsExpr TcId)
+ Inst: tcSyntaxName :: CtOrigin -> TcType -> (Name, HsExpr GhcRn) -> TcM (Name, HsExpr GhcTcId)
- InteractiveEval: ExecOptions :: SingleStep -> String -> Int -> (ForeignHValue -> EvalExpr ForeignHValue) -> ExecOptions
+ InteractiveEval: ExecOptions :: SingleStep -> String -> Int -> ForeignHValue -> EvalExpr ForeignHValue -> ExecOptions
- InteractiveEval: compileParsedExpr :: GhcMonad m => LHsExpr RdrName -> m HValue
+ InteractiveEval: compileParsedExpr :: GhcMonad m => LHsExpr GhcPs -> m HValue
- InteractiveEval: compileParsedExprRemote :: GhcMonad m => LHsExpr RdrName -> m ForeignHValue
+ InteractiveEval: compileParsedExprRemote :: GhcMonad m => LHsExpr GhcPs -> m ForeignHValue
- InteractiveEval: getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
+ InteractiveEval: getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))
- InteractiveEval: parseExpr :: GhcMonad m => String -> m (LHsExpr RdrName)
+ InteractiveEval: parseExpr :: GhcMonad m => String -> m (LHsExpr GhcPs)
- InteractiveEval: parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
+ InteractiveEval: parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs)
- InteractiveEvalTypes: ExecOptions :: SingleStep -> String -> Int -> (ForeignHValue -> EvalExpr ForeignHValue) -> ExecOptions
+ InteractiveEvalTypes: ExecOptions :: SingleStep -> String -> Int -> ForeignHValue -> EvalExpr ForeignHValue -> ExecOptions
- Lexer: ITinteger :: SourceText -> Integer -> Token
+ Lexer: ITinteger :: IntegralLit -> Token
- Lexer: ITline_prag :: Token
+ Lexer: ITline_prag :: SourceText -> Token
- Lexer: P :: (PState -> ParseResult a) -> P a
+ Lexer: P :: PState -> ParseResult a -> P a
- Lexer: PFailed :: SrcSpan -> MsgDoc -> ParseResult a
+ Lexer: PFailed :: (DynFlags -> Messages) -> SrcSpan -> MsgDoc -> ParseResult a
- Lexer: PState :: StringBuffer -> ParserFlags -> (DynFlags -> Messages) -> Maybe RealSrcSpan -> !Int -> Maybe Token -> RealSrcSpan -> !Int -> RealSrcLoc -> [LayoutContext] -> [Int] -> [FastString] -> [RealLocated Token] -> Maybe (RealLocated Token) -> RealSrcSpan -> [ALRContext] -> Maybe ALRLayout -> Bool -> [(ApiAnnKey, [SrcSpan])] -> [Located AnnotationComment] -> [(SrcSpan, [Located AnnotationComment])] -> PState
+ Lexer: PState :: StringBuffer -> ParserFlags -> DynFlags -> Messages -> Maybe RealSrcSpan -> !Int -> Maybe Token -> RealSrcSpan -> !Int -> RealSrcLoc -> [LayoutContext] -> [Int] -> [FastString] -> [RealLocated Token] -> Maybe (RealLocated Token) -> RealSrcSpan -> [ALRContext] -> Maybe ALRLayout -> Bool -> Bool -> [(ApiAnnKey, [SrcSpan])] -> [Located AnnotationComment] -> [(SrcSpan, [Located AnnotationComment])] -> PState
- Lexer: ParserFlags :: IntSet -> IntSet -> UnitId -> !ExtsBitmap -> ParserFlags
+ Lexer: ParserFlags :: EnumSet WarningFlag -> EnumSet Extension -> UnitId -> !ExtsBitmap -> ParserFlags
- Lexer: [pExtensionFlags] :: ParserFlags -> IntSet
+ Lexer: [pExtensionFlags] :: ParserFlags -> EnumSet Extension
- Lexer: [pWarningFlags] :: ParserFlags -> IntSet
+ Lexer: [pWarningFlags] :: ParserFlags -> EnumSet WarningFlag
- ListSetOps: equivClasses :: (a -> a -> Ordering) -> [a] -> [[a]]
+ ListSetOps: equivClasses :: (a -> a -> Ordering) -> [a] -> [NonEmpty a]
- ListSetOps: findDupsEq :: (a -> a -> Bool) -> [a] -> [[a]]
+ ListSetOps: findDupsEq :: (a -> a -> Bool) -> [a] -> [NonEmpty a]
- ListSetOps: minusList :: (Eq a) => [a] -> [a] -> [a]
+ ListSetOps: minusList :: Ord a => [a] -> [a] -> [a]
- ListSetOps: removeDups :: (a -> a -> Ordering) -> [a] -> ([a], [[a]])
+ ListSetOps: removeDups :: (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
- ListT: ListT :: (forall r. (a -> m r -> m r) -> m r -> m r) -> ListT m a
+ ListT: ListT :: forall r. (a -> m r -> m r) -> m r -> m r -> ListT m a
- Match: matchSimply :: CoreExpr -> HsMatchContext Name -> LPat Id -> CoreExpr -> CoreExpr -> DsM CoreExpr
+ Match: matchSimply :: CoreExpr -> HsMatchContext Name -> LPat GhcTc -> CoreExpr -> CoreExpr -> DsM CoreExpr
- Match: matchSinglePat :: CoreExpr -> HsMatchContext Name -> LPat Id -> Type -> MatchResult -> DsM MatchResult
+ Match: matchSinglePat :: CoreExpr -> HsMatchContext Name -> LPat GhcTc -> Type -> MatchResult -> DsM MatchResult
- Match: matchWrapper :: HsMatchContext Name -> Maybe (LHsExpr Id) -> MatchGroup Id (LHsExpr Id) -> DsM ([Id], CoreExpr)
+ Match: matchWrapper :: HsMatchContext Name -> Maybe (LHsExpr GhcTc) -> MatchGroup GhcTc (LHsExpr GhcTc) -> DsM ([Id], CoreExpr)
- MatchLit: dsLit :: HsLit -> DsM CoreExpr
+ MatchLit: dsLit :: HsLit GhcRn -> DsM CoreExpr
- MatchLit: dsOverLit :: HsOverLit Id -> DsM CoreExpr
+ MatchLit: dsOverLit :: HsOverLit GhcTc -> DsM CoreExpr
- MatchLit: dsOverLit' :: DynFlags -> HsOverLit Id -> DsM CoreExpr
+ MatchLit: dsOverLit' :: DynFlags -> HsOverLit GhcTc -> DsM CoreExpr
- MatchLit: hsLitKey :: DynFlags -> HsLit -> Literal
+ MatchLit: hsLitKey :: DynFlags -> HsLit GhcTc -> Literal
- MatchLit: tidyLitPat :: HsLit -> Pat Id
+ MatchLit: tidyLitPat :: HsLit GhcTc -> Pat GhcTc
- MatchLit: tidyNPat :: (HsLit -> Pat Id) -> HsOverLit Id -> Maybe (SyntaxExpr Id) -> SyntaxExpr Id -> Type -> Pat Id
+ MatchLit: tidyNPat :: (HsLit GhcTc -> Pat GhcTc) -> HsOverLit GhcTc -> Maybe (SyntaxExpr GhcTc) -> SyntaxExpr GhcTc -> Type -> Pat GhcTc
- MatchLit: warnAboutEmptyEnumerations :: DynFlags -> LHsExpr Id -> Maybe (LHsExpr Id) -> LHsExpr Id -> DsM ()
+ MatchLit: warnAboutEmptyEnumerations :: DynFlags -> LHsExpr GhcTc -> Maybe (LHsExpr GhcTc) -> LHsExpr GhcTc -> DsM ()
- MatchLit: warnAboutOverflowedLiterals :: DynFlags -> HsOverLit Id -> DsM ()
+ MatchLit: warnAboutOverflowedLiterals :: DynFlags -> HsOverLit GhcTc -> DsM ()
- Maybes: newtype MaybeT (m :: * -> *) a :: (* -> *) -> * -> *
+ Maybes: newtype MaybeT (m :: * -> *) a
- MonadUtils: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ MonadUtils: (<$>) :: Functor f => a -> b -> f a -> f b
- MonadUtils: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ MonadUtils: (<*>) :: Applicative f => f a -> b -> f a -> f b
- MonadUtils: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
+ MonadUtils: mapAndUnzipM :: Applicative m => a -> m (b, c) -> [a] -> m ([b], [c])
- MonadUtils: mfix :: MonadFix m => (a -> m a) -> m a
+ MonadUtils: mfix :: MonadFix m => a -> m a -> m a
- Outputable: ifPprDebug :: SDoc -> SDoc
+ Outputable: ifPprDebug :: SDoc -> SDoc -> SDoc
- PPC.Instr: BCC :: Cond -> BlockId -> Instr
+ PPC.Instr: BCC :: Cond -> BlockId -> (Maybe Bool) -> Instr
- PPC.Instr: BCCFAR :: Cond -> BlockId -> Instr
+ PPC.Instr: BCCFAR :: Cond -> BlockId -> (Maybe Bool) -> Instr
- PackageConfig: data InstalledPackageInfo compid srcpkgid srcpkgname instunitid unitid modulename mod :: * -> * -> * -> * -> * -> * -> * -> *
+ PackageConfig: data InstalledPackageInfo compid srcpkgid srcpkgname instunitid unitid modulename mod
- PackageConfig: data Version :: *
+ PackageConfig: data Version
- Panic: class (Typeable * e, Show e) => Exception e
+ Panic: class (Typeable e, Show e) => Exception e
- Parser: parseDeclaration :: P LHsDecl RdrName
+ Parser: parseDeclaration :: P LHsDecl GhcPs
- Parser: parseExpression :: P LHsExpr RdrName
+ Parser: parseExpression :: P LHsExpr GhcPs
- Parser: parseHeader :: P Located HsModule RdrName
+ Parser: parseHeader :: P Located HsModule GhcPs
- Parser: parseImport :: P LImportDecl RdrName
+ Parser: parseImport :: P LImportDecl GhcPs
- Parser: parseModule :: P Located HsModule RdrName
+ Parser: parseModule :: P Located HsModule GhcPs
- Parser: parsePattern :: P LPat RdrName
+ Parser: parsePattern :: P LPat GhcPs
- Parser: parseSignature :: P Located HsModule RdrName
+ Parser: parseSignature :: P Located HsModule GhcPs
- Parser: parseStatement :: P LStmt RdrName LHsExpr RdrName
+ Parser: parseStatement :: P LStmt GhcPs LHsExpr GhcPs
- Parser: parseStmt :: P Maybe LStmt RdrName LHsExpr RdrName
+ Parser: parseStmt :: P Maybe LStmt GhcPs LHsExpr GhcPs
- Parser: parseType :: P LHsType RdrName
+ Parser: parseType :: P LHsType GhcPs
- Parser: parseTypeSignature :: P LHsDecl RdrName
+ Parser: parseTypeSignature :: P LHsDecl GhcPs
- PipelineMonad: P :: (PipeEnv -> PipeState -> IO (PipeState, a)) -> CompPipeline a
+ PipelineMonad: P :: PipeEnv -> PipeState -> IO (PipeState, a) -> CompPipeline a
- PipelineMonad: Temporary :: PipelineOutput
+ PipelineMonad: Temporary :: TempFileLifetime -> PipelineOutput
- Plugins: Plugin :: ([CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]) -> ([CommandLineOption] -> Maybe TcPlugin) -> Plugin
+ Plugins: Plugin :: [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo] -> [CommandLineOption] -> Maybe TcPlugin -> Plugin
- PmExpr: PmExprOther :: (HsExpr Id) -> PmExpr
+ PmExpr: PmExprOther :: (HsExpr GhcTc) -> PmExpr
- PmExpr: PmOLit :: Bool -> (HsOverLit Id) -> PmLit
+ PmExpr: PmOLit :: Bool -> (HsOverLit GhcTc) -> PmLit
- PmExpr: PmSLit :: HsLit -> PmLit
+ PmExpr: PmSLit :: (HsLit GhcTc) -> PmLit
- PmExpr: hsExprToPmExpr :: HsExpr Id -> PmExpr
+ PmExpr: hsExprToPmExpr :: HsExpr GhcTc -> PmExpr
- PmExpr: lhsExprToPmExpr :: LHsExpr Id -> PmExpr
+ PmExpr: lhsExprToPmExpr :: LHsExpr GhcTc -> PmExpr
- PrelRules: caseRules :: DynFlags -> CoreExpr -> Maybe (CoreExpr, Integer -> Integer)
+ PrelRules: caseRules :: DynFlags -> CoreExpr -> Maybe (CoreExpr, AltCon -> AltCon, Id -> CoreExpr)
- RdrHsSyn: Sum :: ConTag -> Arity -> (LHsExpr RdrName) -> SumOrTuple
+ RdrHsSyn: Sum :: ConTag -> Arity -> (LHsExpr GhcPs) -> SumOrTuple
- RdrHsSyn: Tuple :: [LHsTupArg RdrName] -> SumOrTuple
+ RdrHsSyn: Tuple :: [LHsTupArg GhcPs] -> SumOrTuple
- RdrHsSyn: checkCommand :: LHsExpr RdrName -> P (LHsCmd RdrName)
+ RdrHsSyn: checkCommand :: LHsExpr GhcPs -> P (LHsCmd GhcPs)
- RdrHsSyn: checkContext :: LHsType RdrName -> P ([AddAnn], LHsContext RdrName)
+ RdrHsSyn: checkContext :: LHsType GhcPs -> P ([AddAnn], LHsContext GhcPs)
- RdrHsSyn: checkDoAndIfThenElse :: LHsExpr RdrName -> Bool -> LHsExpr RdrName -> Bool -> LHsExpr RdrName -> P ()
+ RdrHsSyn: checkDoAndIfThenElse :: LHsExpr GhcPs -> Bool -> LHsExpr GhcPs -> Bool -> LHsExpr GhcPs -> P ()
- RdrHsSyn: checkImportSpec :: Located [LIE RdrName] -> P (Located [LIE RdrName])
+ RdrHsSyn: checkImportSpec :: Located [LIE GhcPs] -> P (Located [LIE GhcPs])
- RdrHsSyn: checkPattern :: SDoc -> LHsExpr RdrName -> P (LPat RdrName)
+ RdrHsSyn: checkPattern :: SDoc -> LHsExpr GhcPs -> P (LPat GhcPs)
- RdrHsSyn: checkPatterns :: SDoc -> [LHsExpr RdrName] -> P [LPat RdrName]
+ RdrHsSyn: checkPatterns :: SDoc -> [LHsExpr GhcPs] -> P [LPat GhcPs]
- RdrHsSyn: checkValDef :: SDoc -> SrcStrictness -> LHsExpr RdrName -> Maybe (LHsType RdrName) -> Located (a, GRHSs RdrName (LHsExpr RdrName)) -> P ([AddAnn], HsBind RdrName)
+ RdrHsSyn: checkValDef :: SDoc -> SrcStrictness -> LHsExpr GhcPs -> Maybe (LHsType GhcPs) -> Located (a, GRHSs GhcPs (LHsExpr GhcPs)) -> P ([AddAnn], HsBind GhcPs)
- RdrHsSyn: checkValSigLhs :: LHsExpr RdrName -> P (Located RdrName)
+ RdrHsSyn: checkValSigLhs :: LHsExpr GhcPs -> P (Located RdrName)
- RdrHsSyn: cvBindGroup :: OrdList (LHsDecl RdrName) -> P (HsValBinds RdrName)
+ RdrHsSyn: cvBindGroup :: OrdList (LHsDecl GhcPs) -> P (HsValBinds GhcPs)
- RdrHsSyn: cvBindsAndSigs :: OrdList (LHsDecl RdrName) -> P (LHsBinds RdrName, [LSig RdrName], [LFamilyDecl RdrName], [LTyFamInstDecl RdrName], [LDataFamInstDecl RdrName], [LDocDecl])
+ RdrHsSyn: cvBindsAndSigs :: OrdList (LHsDecl GhcPs) -> P (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs], [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl])
- RdrHsSyn: cvTopDecls :: OrdList (LHsDecl RdrName) -> [LHsDecl RdrName]
+ RdrHsSyn: cvTopDecls :: OrdList (LHsDecl GhcPs) -> [LHsDecl GhcPs]
- RdrHsSyn: mkATDefault :: LTyFamInstDecl RdrName -> Either (SrcSpan, SDoc) (LTyFamDefltEqn RdrName)
+ RdrHsSyn: mkATDefault :: LTyFamInstDecl GhcPs -> Either (SrcSpan, SDoc) (LTyFamDefltEqn GhcPs)
- RdrHsSyn: mkClassDecl :: SrcSpan -> Located (Maybe (LHsContext RdrName), LHsType RdrName) -> Located (a, [Located (FunDep (Located RdrName))]) -> OrdList (LHsDecl RdrName) -> P (LTyClDecl RdrName)
+ RdrHsSyn: mkClassDecl :: SrcSpan -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Located (a, [Located (FunDep (Located RdrName))]) -> OrdList (LHsDecl GhcPs) -> P (LTyClDecl GhcPs)
- RdrHsSyn: mkConDeclH98 :: Located RdrName -> Maybe [LHsTyVarBndr RdrName] -> LHsContext RdrName -> HsConDeclDetails RdrName -> ConDecl RdrName
+ RdrHsSyn: mkConDeclH98 :: Located RdrName -> Maybe [LHsTyVarBndr GhcPs] -> LHsContext GhcPs -> HsConDeclDetails GhcPs -> ConDecl GhcPs
- RdrHsSyn: mkDataFamInst :: SrcSpan -> NewOrData -> Maybe (Located CType) -> Located (Maybe (LHsContext RdrName), LHsType RdrName) -> Maybe (LHsKind RdrName) -> [LConDecl RdrName] -> HsDeriving RdrName -> P (LInstDecl RdrName)
+ RdrHsSyn: mkDataFamInst :: SrcSpan -> NewOrData -> Maybe (Located CType) -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Maybe (LHsKind GhcPs) -> [LConDecl GhcPs] -> HsDeriving GhcPs -> P (LInstDecl GhcPs)
- RdrHsSyn: mkExport :: Located CCallConv -> (Located StringLiteral, Located RdrName, LHsSigType RdrName) -> P (HsDecl RdrName)
+ RdrHsSyn: mkExport :: Located CCallConv -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs) -> P (HsDecl GhcPs)
- RdrHsSyn: mkFamDecl :: SrcSpan -> FamilyInfo RdrName -> LHsType RdrName -> Located (FamilyResultSig RdrName) -> Maybe (LInjectivityAnn RdrName) -> P (LTyClDecl RdrName)
+ RdrHsSyn: mkFamDecl :: SrcSpan -> FamilyInfo GhcPs -> LHsType GhcPs -> Located (FamilyResultSig GhcPs) -> Maybe (LInjectivityAnn GhcPs) -> P (LTyClDecl GhcPs)
- RdrHsSyn: mkGadtDecl :: [Located RdrName] -> LHsSigType RdrName -> ConDecl RdrName
+ RdrHsSyn: mkGadtDecl :: [Located RdrName] -> LHsSigType GhcPs -> ConDecl GhcPs
- RdrHsSyn: mkHsDo :: HsStmtContext Name -> [ExprLStmt RdrName] -> HsExpr RdrName
+ RdrHsSyn: mkHsDo :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs
- RdrHsSyn: mkHsFractional :: FractionalLit -> PostTc RdrName Type -> HsOverLit RdrName
+ RdrHsSyn: mkHsFractional :: FractionalLit -> PostTc GhcPs Type -> HsOverLit GhcPs
- RdrHsSyn: mkHsIntegral :: SourceText -> Integer -> PostTc RdrName Type -> HsOverLit RdrName
+ RdrHsSyn: mkHsIntegral :: IntegralLit -> PostTc GhcPs Type -> HsOverLit GhcPs
- RdrHsSyn: mkHsIsString :: SourceText -> FastString -> PostTc RdrName Type -> HsOverLit RdrName
+ RdrHsSyn: mkHsIsString :: SourceText -> FastString -> PostTc GhcPs Type -> HsOverLit GhcPs
- RdrHsSyn: mkHsOpApp :: LHsExpr id -> id -> LHsExpr id -> HsExpr id
+ RdrHsSyn: mkHsOpApp :: LHsExpr id -> IdP id -> LHsExpr id -> HsExpr id
- RdrHsSyn: mkImport :: Located CCallConv -> Located Safety -> (Located StringLiteral, Located RdrName, LHsSigType RdrName) -> P (HsDecl RdrName)
+ RdrHsSyn: mkImport :: Located CCallConv -> Located Safety -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs) -> P (HsDecl GhcPs)
- RdrHsSyn: mkLHsSigType :: LHsType RdrName -> LHsSigType RdrName
+ RdrHsSyn: mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs
- RdrHsSyn: mkModuleImpExp :: Located ImpExpQcSpec -> ImpExpSubSpec -> P (IE RdrName)
+ RdrHsSyn: mkModuleImpExp :: Located ImpExpQcSpec -> ImpExpSubSpec -> P (IE GhcPs)
- RdrHsSyn: mkPatSynMatchGroup :: Located RdrName -> Located (OrdList (LHsDecl RdrName)) -> P (MatchGroup RdrName (LHsExpr RdrName))
+ RdrHsSyn: mkPatSynMatchGroup :: Located RdrName -> Located (OrdList (LHsDecl GhcPs)) -> P (MatchGroup GhcPs (LHsExpr GhcPs))
- RdrHsSyn: mkRdrRecordCon :: Located RdrName -> HsRecordBinds RdrName -> HsExpr RdrName
+ RdrHsSyn: mkRdrRecordCon :: Located RdrName -> HsRecordBinds GhcPs -> HsExpr GhcPs
- RdrHsSyn: mkRdrRecordUpd :: LHsExpr RdrName -> [LHsRecUpdField RdrName] -> HsExpr RdrName
+ RdrHsSyn: mkRdrRecordUpd :: LHsExpr GhcPs -> [LHsRecUpdField GhcPs] -> HsExpr GhcPs
- RdrHsSyn: mkRecConstrOrUpdate :: LHsExpr RdrName -> SrcSpan -> ([LHsRecField RdrName (LHsExpr RdrName)], Bool) -> P (HsExpr RdrName)
+ RdrHsSyn: mkRecConstrOrUpdate :: LHsExpr GhcPs -> SrcSpan -> ([LHsRecField GhcPs (LHsExpr GhcPs)], Bool) -> P (HsExpr GhcPs)
- RdrHsSyn: mkRoleAnnotDecl :: SrcSpan -> Located RdrName -> [Located (Maybe FastString)] -> P (LRoleAnnotDecl RdrName)
+ RdrHsSyn: mkRoleAnnotDecl :: SrcSpan -> Located RdrName -> [Located (Maybe FastString)] -> P (LRoleAnnotDecl GhcPs)
- RdrHsSyn: mkSpliceDecl :: LHsExpr RdrName -> HsDecl RdrName
+ RdrHsSyn: mkSpliceDecl :: LHsExpr GhcPs -> HsDecl GhcPs
- RdrHsSyn: mkSumOrTuple :: Boxity -> SrcSpan -> SumOrTuple -> P (HsExpr RdrName)
+ RdrHsSyn: mkSumOrTuple :: Boxity -> SrcSpan -> SumOrTuple -> P (HsExpr GhcPs)
- RdrHsSyn: mkTyData :: SrcSpan -> NewOrData -> Maybe (Located CType) -> Located (Maybe (LHsContext RdrName), LHsType RdrName) -> Maybe (LHsKind RdrName) -> [LConDecl RdrName] -> HsDeriving RdrName -> P (LTyClDecl RdrName)
+ RdrHsSyn: mkTyData :: SrcSpan -> NewOrData -> Maybe (Located CType) -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Maybe (LHsKind GhcPs) -> [LConDecl GhcPs] -> HsDeriving GhcPs -> P (LTyClDecl GhcPs)
- RdrHsSyn: mkTyFamInst :: SrcSpan -> LTyFamInstEqn RdrName -> P (LInstDecl RdrName)
+ RdrHsSyn: mkTyFamInst :: SrcSpan -> TyFamInstEqn GhcPs -> P (LInstDecl GhcPs)
- RdrHsSyn: mkTyFamInstEqn :: LHsType RdrName -> LHsType RdrName -> P (TyFamInstEqn RdrName, [AddAnn])
+ RdrHsSyn: mkTyFamInstEqn :: LHsType GhcPs -> LHsType GhcPs -> P (TyFamInstEqn GhcPs, [AddAnn])
- RdrHsSyn: mkTySynonym :: SrcSpan -> LHsType RdrName -> LHsType RdrName -> P (LTyClDecl RdrName)
+ RdrHsSyn: mkTySynonym :: SrcSpan -> LHsType GhcPs -> LHsType GhcPs -> P (LTyClDecl GhcPs)
- RdrHsSyn: placeHolderPunRhs :: LHsExpr RdrName
+ RdrHsSyn: placeHolderPunRhs :: LHsExpr GhcPs
- RdrHsSyn: splitCon :: LHsType RdrName -> P (Located RdrName, HsConDeclDetails RdrName)
+ RdrHsSyn: splitCon :: LHsType GhcPs -> P (Located RdrName, HsConDeclDetails GhcPs)
- RdrHsSyn: splitTilde :: LHsType RdrName -> P (LHsType RdrName)
+ RdrHsSyn: splitTilde :: LHsType GhcPs -> P (LHsType GhcPs)
- RdrHsSyn: splitTildeApps :: [LHsAppType RdrName] -> P [LHsAppType RdrName]
+ RdrHsSyn: splitTildeApps :: [LHsAppType GhcPs] -> P [LHsAppType GhcPs]
- RegAlloc.Liveness: mapEmpty :: IsMap map => forall a. () => map a
+ RegAlloc.Liveness: mapEmpty :: IsMap map => map a
- RnBinds: makeMiniFixityEnv :: [LFixitySig RdrName] -> RnM MiniFixityEnv
+ RnBinds: makeMiniFixityEnv :: [LFixitySig GhcPs] -> RnM MiniFixityEnv
- RnBinds: renameSigs :: HsSigCtxt -> [LSig RdrName] -> RnM ([LSig Name], FreeVars)
+ RnBinds: renameSigs :: HsSigCtxt -> [LSig GhcPs] -> RnM ([LSig GhcRn], FreeVars)
- RnBinds: rnGRHS :: HsMatchContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> LGRHS RdrName (Located (body RdrName)) -> RnM (LGRHS Name (Located (body Name)), FreeVars)
+ RnBinds: rnGRHS :: HsMatchContext Name -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -> LGRHS GhcPs (Located (body GhcPs)) -> RnM (LGRHS GhcRn (Located (body GhcRn)), FreeVars)
- RnBinds: rnGRHSs :: HsMatchContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> GRHSs RdrName (Located (body RdrName)) -> RnM (GRHSs Name (Located (body Name)), FreeVars)
+ RnBinds: rnGRHSs :: HsMatchContext Name -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -> GRHSs GhcPs (Located (body GhcPs)) -> RnM (GRHSs GhcRn (Located (body GhcRn)), FreeVars)
- RnBinds: rnLocalBindsAndThen :: HsLocalBinds RdrName -> (HsLocalBinds Name -> FreeVars -> RnM (result, FreeVars)) -> RnM (result, FreeVars)
+ RnBinds: rnLocalBindsAndThen :: HsLocalBinds GhcPs -> (HsLocalBinds GhcRn -> FreeVars -> RnM (result, FreeVars)) -> RnM (result, FreeVars)
- RnBinds: rnLocalValBindsLHS :: MiniFixityEnv -> HsValBinds RdrName -> RnM ([Name], HsValBindsLR Name RdrName)
+ RnBinds: rnLocalValBindsLHS :: MiniFixityEnv -> HsValBinds GhcPs -> RnM ([Name], HsValBindsLR GhcRn GhcPs)
- RnBinds: rnLocalValBindsRHS :: NameSet -> HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)
+ RnBinds: rnLocalValBindsRHS :: NameSet -> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)
- RnBinds: rnMatchGroup :: Outputable (body RdrName) => HsMatchContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> MatchGroup RdrName (Located (body RdrName)) -> RnM (MatchGroup Name (Located (body Name)), FreeVars)
+ RnBinds: rnMatchGroup :: Outputable (body GhcPs) => HsMatchContext Name -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -> MatchGroup GhcPs (Located (body GhcPs)) -> RnM (MatchGroup GhcRn (Located (body GhcRn)), FreeVars)
- RnBinds: rnMethodBinds :: Bool -> Name -> [Name] -> LHsBinds RdrName -> [LSig RdrName] -> RnM (LHsBinds Name, [LSig Name], FreeVars)
+ RnBinds: rnMethodBinds :: Bool -> Name -> [Name] -> LHsBinds GhcPs -> [LSig GhcPs] -> RnM (LHsBinds GhcRn, [LSig GhcRn], FreeVars)
- RnBinds: rnTopBindsBoot :: NameSet -> HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)
+ RnBinds: rnTopBindsBoot :: NameSet -> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)
- RnBinds: rnTopBindsLHS :: MiniFixityEnv -> HsValBinds RdrName -> RnM (HsValBindsLR Name RdrName)
+ RnBinds: rnTopBindsLHS :: MiniFixityEnv -> HsValBinds GhcPs -> RnM (HsValBindsLR GhcRn GhcPs)
- RnBinds: rnValBindsRHS :: HsSigCtxt -> HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)
+ RnBinds: rnValBindsRHS :: HsSigCtxt -> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)
- RnEnv: lookupGlobalOccRn_overloaded :: Bool -> RdrName -> RnM (Maybe (Either Name [FieldOcc Name]))
+ RnEnv: lookupGlobalOccRn_overloaded :: Bool -> RdrName -> RnM (Maybe (Either Name [Name]))
- RnEnv: lookupIfThenElse :: RnM (Maybe (SyntaxExpr Name), FreeVars)
+ RnEnv: lookupIfThenElse :: RnM (Maybe (SyntaxExpr GhcRn), FreeVars)
- RnEnv: lookupOccRn_overloaded :: Bool -> RdrName -> RnM (Maybe (Either Name [FieldOcc Name]))
+ RnEnv: lookupOccRn_overloaded :: Bool -> RdrName -> RnM (Maybe (Either Name [Name]))
- RnEnv: lookupSigOccRn :: HsSigCtxt -> Sig RdrName -> Located RdrName -> RnM (Located Name)
+ RnEnv: lookupSigOccRn :: HsSigCtxt -> Sig GhcPs -> Located RdrName -> RnM (Located Name)
- RnEnv: lookupSyntaxName :: Name -> RnM (SyntaxExpr Name, FreeVars)
+ RnEnv: lookupSyntaxName :: Name -> RnM (SyntaxExpr GhcRn, FreeVars)
- RnEnv: lookupSyntaxNames :: [Name] -> RnM ([HsExpr Name], FreeVars)
+ RnEnv: lookupSyntaxNames :: [Name] -> RnM ([HsExpr GhcRn], FreeVars)
- RnExpr: rnExpr :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars)
+ RnExpr: rnExpr :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
- RnExpr: rnLExpr :: LHsExpr RdrName -> RnM (LHsExpr Name, FreeVars)
+ RnExpr: rnLExpr :: LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
- RnExpr: rnStmts :: Outputable (body RdrName) => HsStmtContext Name -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars)) -> [LStmt RdrName (Located (body RdrName))] -> ([Name] -> RnM (thing, FreeVars)) -> RnM (([LStmt Name (Located (body Name))], thing), FreeVars)
+ RnExpr: rnStmts :: Outputable (body GhcPs) => HsStmtContext Name -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -> [LStmt GhcPs (Located (body GhcPs))] -> ([Name] -> RnM (thing, FreeVars)) -> RnM (([LStmt GhcRn (Located (body GhcRn))], thing), FreeVars)
- RnNames: dodgyMsg :: (OutputableBndr n, HasOccName n) => SDoc -> n -> SDoc
+ RnNames: dodgyMsg :: (Outputable a, Outputable b) => SDoc -> a -> b -> SDoc
- RnNames: getLocalNonValBinders :: MiniFixityEnv -> HsGroup RdrName -> RnM ((TcGblEnv, TcLclEnv), NameSet)
+ RnNames: getLocalNonValBinders :: MiniFixityEnv -> HsGroup GhcPs -> RnM ((TcGblEnv, TcLclEnv), NameSet)
- RnNames: newRecordSelector :: Bool -> [Name] -> LFieldOcc RdrName -> RnM FieldLabel
+ RnNames: newRecordSelector :: Bool -> [Name] -> LFieldOcc GhcPs -> RnM FieldLabel
- RnNames: reportUnusedNames :: Maybe (Located [LIE RdrName]) -> TcGblEnv -> RnM ()
+ RnNames: reportUnusedNames :: Maybe (Located [LIE GhcPs]) -> TcGblEnv -> RnM ()
- RnNames: rnImports :: [LImportDecl RdrName] -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails, AnyHpcUsage)
+ RnNames: rnImports :: [LImportDecl GhcPs] -> RnM ([LImportDecl GhcRn], GlobalRdrEnv, ImportAvails, AnyHpcUsage)
- RnPat: rnBindPat :: NameMaker -> LPat RdrName -> RnM (LPat Name, FreeVars)
+ RnPat: rnBindPat :: NameMaker -> LPat GhcPs -> RnM (LPat GhcRn, FreeVars)
- RnPat: rnHsRecFields :: forall arg. HsRecFieldContext -> (SrcSpan -> RdrName -> arg) -> HsRecFields RdrName (Located arg) -> RnM ([LHsRecField Name (Located arg)], FreeVars)
+ RnPat: rnHsRecFields :: forall arg. HsRecFieldContext -> (SrcSpan -> RdrName -> arg) -> HsRecFields GhcPs (Located arg) -> RnM ([LHsRecField GhcRn (Located arg)], FreeVars)
- RnPat: rnHsRecUpdFields :: [LHsRecUpdField RdrName] -> RnM ([LHsRecUpdField Name], FreeVars)
+ RnPat: rnHsRecUpdFields :: [LHsRecUpdField GhcPs] -> RnM ([LHsRecUpdField GhcRn], FreeVars)
- RnPat: rnLit :: HsLit -> RnM ()
+ RnPat: rnLit :: HsLit p -> RnM ()
- RnPat: rnOverLit :: HsOverLit t -> RnM (HsOverLit Name, FreeVars)
+ RnPat: rnOverLit :: HsOverLit t -> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
- RnPat: rnPat :: HsMatchContext Name -> LPat RdrName -> (LPat Name -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
+ RnPat: rnPat :: HsMatchContext Name -> LPat GhcPs -> (LPat GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
- RnPat: rnPatAndThen :: NameMaker -> Pat RdrName -> CpsRn (Pat Name)
+ RnPat: rnPatAndThen :: NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn)
- RnPat: rnPats :: HsMatchContext Name -> [LPat RdrName] -> ([LPat Name] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
+ RnPat: rnPats :: HsMatchContext Name -> [LPat GhcPs] -> ([LPat GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
- RnSource: findSplice :: [LHsDecl RdrName] -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))
+ RnSource: findSplice :: [LHsDecl GhcPs] -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
- RnSource: rnSrcDecls :: HsGroup RdrName -> RnM (TcGblEnv, HsGroup Name)
+ RnSource: rnSrcDecls :: HsGroup GhcPs -> RnM (TcGblEnv, HsGroup GhcRn)
- RnSplice: SpliceInfo :: String -> Maybe (LHsExpr Name) -> Bool -> SDoc -> SpliceInfo
+ RnSplice: SpliceInfo :: String -> Maybe (LHsExpr GhcRn) -> Bool -> SDoc -> SpliceInfo
- RnSplice: [spliceSource] :: SpliceInfo -> Maybe (LHsExpr Name)
+ RnSplice: [spliceSource] :: SpliceInfo -> Maybe (LHsExpr GhcRn)
- RnSplice: rnBracket :: HsExpr RdrName -> HsBracket RdrName -> RnM (HsExpr Name, FreeVars)
+ RnSplice: rnBracket :: HsExpr GhcPs -> HsBracket GhcPs -> RnM (HsExpr GhcRn, FreeVars)
- RnSplice: rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)
+ RnSplice: rnSpliceDecl :: SpliceDecl GhcPs -> RnM (SpliceDecl GhcRn, FreeVars)
- RnSplice: rnSpliceExpr :: HsSplice RdrName -> RnM (HsExpr Name, FreeVars)
+ RnSplice: rnSpliceExpr :: HsSplice GhcPs -> RnM (HsExpr GhcRn, FreeVars)
- RnSplice: rnSplicePat :: HsSplice RdrName -> RnM (Either (Pat RdrName) (Pat Name), FreeVars)
+ RnSplice: rnSplicePat :: HsSplice GhcPs -> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
- RnSplice: rnSpliceType :: HsSplice RdrName -> PostTc Name Kind -> RnM (HsType Name, FreeVars)
+ RnSplice: rnSpliceType :: HsSplice GhcPs -> PostTc GhcRn Kind -> RnM (HsType GhcRn, FreeVars)
- RnSplice: rnTopSpliceDecls :: HsSplice RdrName -> RnM ([LHsDecl RdrName], FreeVars)
+ RnSplice: rnTopSpliceDecls :: HsSplice GhcPs -> RnM ([LHsDecl GhcPs], FreeVars)
- RnTypes: bindHsQTyVars :: forall a b. HsDocContext -> Maybe SDoc -> Maybe a -> [Located RdrName] -> (LHsQTyVars RdrName) -> (LHsQTyVars Name -> NameSet -> RnM (b, FreeVars)) -> RnM (b, FreeVars)
+ RnTypes: bindHsQTyVars :: forall a b. HsDocContext -> Maybe SDoc -> Maybe a -> [Located RdrName] -> (LHsQTyVars GhcPs) -> (LHsQTyVars GhcRn -> Bool -> RnM (b, FreeVars)) -> RnM (b, FreeVars)
- RnTypes: bindLHsTyVarBndr :: HsDocContext -> Maybe a -> NameSet -> NameSet -> LHsTyVarBndr RdrName -> ([Name] -> NameSet -> LHsTyVarBndr Name -> RnM (b, FreeVars)) -> RnM (b, FreeVars)
+ RnTypes: bindLHsTyVarBndr :: HsDocContext -> Maybe a -> LHsTyVarBndr GhcPs -> (LHsTyVarBndr GhcRn -> RnM (b, FreeVars)) -> RnM (b, FreeVars)
- RnTypes: checkPrecMatch :: Name -> MatchGroup Name body -> RnM ()
+ RnTypes: checkPrecMatch :: Name -> MatchGroup GhcRn body -> RnM ()
- RnTypes: checkSectionPrec :: FixityDirection -> HsExpr RdrName -> LHsExpr Name -> LHsExpr Name -> RnM ()
+ RnTypes: checkSectionPrec :: FixityDirection -> HsExpr GhcPs -> LHsExpr GhcRn -> LHsExpr GhcRn -> RnM ()
- RnTypes: collectAnonWildCards :: LHsType Name -> [Name]
+ RnTypes: collectAnonWildCards :: LHsType GhcRn -> [Name]
- RnTypes: extractDataDefnKindVars :: HsDataDefn RdrName -> RnM [Located RdrName]
+ RnTypes: extractDataDefnKindVars :: HsDataDefn GhcPs -> RnM [Located RdrName]
- RnTypes: extractFilteredRdrTyVars :: LHsType RdrName -> RnM FreeKiTyVars
+ RnTypes: extractFilteredRdrTyVars :: LHsType GhcPs -> RnM FreeKiTyVarsNoDups
- RnTypes: extractHsTyRdrTyVars :: LHsType RdrName -> RnM FreeKiTyVars
+ RnTypes: extractHsTyRdrTyVars :: LHsType GhcPs -> RnM FreeKiTyVarsNoDups
- RnTypes: extractHsTysRdrTyVars :: [LHsType RdrName] -> RnM FreeKiTyVars
+ RnTypes: extractHsTysRdrTyVars :: [LHsType GhcPs] -> RnM FreeKiTyVarsNoDups
- RnTypes: extractHsTysRdrTyVarsDups :: [LHsType RdrName] -> RnM FreeKiTyVars
+ RnTypes: extractHsTysRdrTyVarsDups :: [LHsType GhcPs] -> RnM FreeKiTyVarsWithDups
- RnTypes: extractRdrKindSigVars :: LFamilyResultSig RdrName -> RnM [Located RdrName]
+ RnTypes: extractRdrKindSigVars :: LFamilyResultSig GhcPs -> RnM [Located RdrName]
- RnTypes: mkConOpPatRn :: Located Name -> Fixity -> LPat Name -> LPat Name -> RnM (Pat Name)
+ RnTypes: mkConOpPatRn :: Located Name -> Fixity -> LPat GhcRn -> LPat GhcRn -> RnM (Pat GhcRn)
- RnTypes: mkOpAppRn :: LHsExpr Name -> LHsExpr Name -> Fixity -> LHsExpr Name -> RnM (HsExpr Name)
+ RnTypes: mkOpAppRn :: LHsExpr GhcRn -> LHsExpr GhcRn -> Fixity -> LHsExpr GhcRn -> RnM (HsExpr GhcRn)
- RnTypes: mkOpFormRn :: LHsCmdTop Name -> LHsExpr Name -> Fixity -> LHsCmdTop Name -> RnM (HsCmd Name)
+ RnTypes: mkOpFormRn :: LHsCmdTop GhcRn -> LHsExpr GhcRn -> Fixity -> LHsCmdTop GhcRn -> RnM (HsCmd GhcRn)
- RnTypes: rmDupsInRdrTyVars :: FreeKiTyVars -> FreeKiTyVars
+ RnTypes: rmDupsInRdrTyVars :: FreeKiTyVarsWithDups -> FreeKiTyVarsNoDups
- RnTypes: rnConDeclFields :: HsDocContext -> [FieldLabel] -> [LConDeclField RdrName] -> RnM ([LConDeclField Name], FreeVars)
+ RnTypes: rnConDeclFields :: HsDocContext -> [FieldLabel] -> [LConDeclField GhcPs] -> RnM ([LConDeclField GhcRn], FreeVars)
- RnTypes: rnContext :: HsDocContext -> LHsContext RdrName -> RnM (LHsContext Name, FreeVars)
+ RnTypes: rnContext :: HsDocContext -> LHsContext GhcPs -> RnM (LHsContext GhcRn, FreeVars)
- RnTypes: rnHsKind :: HsDocContext -> HsKind RdrName -> RnM (HsKind Name, FreeVars)
+ RnTypes: rnHsKind :: HsDocContext -> HsKind GhcPs -> RnM (HsKind GhcRn, FreeVars)
- RnTypes: rnHsSigType :: HsDocContext -> LHsSigType RdrName -> RnM (LHsSigType Name, FreeVars)
+ RnTypes: rnHsSigType :: HsDocContext -> LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars)
- RnTypes: rnHsSigWcType :: HsDocContext -> LHsSigWcType RdrName -> RnM (LHsSigWcType Name, FreeVars)
+ RnTypes: rnHsSigWcType :: HsDocContext -> LHsSigWcType GhcPs -> RnM (LHsSigWcType GhcRn, FreeVars)
- RnTypes: rnHsSigWcTypeScoped :: HsDocContext -> LHsSigWcType RdrName -> (LHsSigWcType Name -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
+ RnTypes: rnHsSigWcTypeScoped :: HsDocContext -> LHsSigWcType GhcPs -> (LHsSigWcType GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars)
- RnTypes: rnHsType :: HsDocContext -> HsType RdrName -> RnM (HsType Name, FreeVars)
+ RnTypes: rnHsType :: HsDocContext -> HsType GhcPs -> RnM (HsType GhcRn, FreeVars)
- RnTypes: rnHsWcType :: HsDocContext -> LHsWcType RdrName -> RnM (LHsWcType Name, FreeVars)
+ RnTypes: rnHsWcType :: HsDocContext -> LHsWcType GhcPs -> RnM (LHsWcType GhcRn, FreeVars)
- RnTypes: rnLHsInstType :: SDoc -> LHsSigType RdrName -> RnM (LHsSigType Name, FreeVars)
+ RnTypes: rnLHsInstType :: SDoc -> LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars)
- RnTypes: rnLHsKind :: HsDocContext -> LHsKind RdrName -> RnM (LHsKind Name, FreeVars)
+ RnTypes: rnLHsKind :: HsDocContext -> LHsKind GhcPs -> RnM (LHsKind GhcRn, FreeVars)
- RnTypes: rnLHsType :: HsDocContext -> LHsType RdrName -> RnM (LHsType Name, FreeVars)
+ RnTypes: rnLHsType :: HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
- RnTypes: rnLHsTypes :: HsDocContext -> [LHsType RdrName] -> RnM ([LHsType Name], FreeVars)
+ RnTypes: rnLHsTypes :: HsDocContext -> [LHsType GhcPs] -> RnM ([LHsType GhcRn], FreeVars)
- RtClosureInspect: Closure :: ClosureType -> Ptr () -> StgInfoTable -> Array Int HValue -> [Word] -> Closure
+ RtClosureInspect: Closure :: ClosureType -> Ptr () -> StgInfoTable -> Array Int HValue -> ClosureNonPtrs -> Closure
- RtClosureInspect: TermFold :: TermProcessor a a -> (RttiType -> [Word] -> a) -> (ClosureType -> RttiType -> HValue -> Maybe Name -> a) -> (RttiType -> Either String DataCon -> a -> a) -> (RttiType -> a -> a) -> TermFold a
+ RtClosureInspect: TermFold :: TermProcessor a a -> RttiType -> [Word] -> a -> ClosureType -> RttiType -> HValue -> Maybe Name -> a -> RttiType -> Either String DataCon -> a -> a -> RttiType -> a -> a -> TermFold a
- RtClosureInspect: TermFoldM :: TermProcessor a (m a) -> (RttiType -> [Word] -> m a) -> (ClosureType -> RttiType -> HValue -> Maybe Name -> m a) -> (RttiType -> Either String DataCon -> a -> m a) -> (RttiType -> a -> m a) -> TermFoldM m a
+ RtClosureInspect: TermFoldM :: TermProcessor a (m a) -> RttiType -> [Word] -> m a -> ClosureType -> RttiType -> HValue -> Maybe Name -> m a -> RttiType -> Either String DataCon -> a -> m a -> RttiType -> a -> m a -> TermFoldM m a
- RtClosureInspect: [nonPtrs] :: Closure -> [Word]
+ RtClosureInspect: [nonPtrs] :: Closure -> ClosureNonPtrs
- SMRep: Constr :: ConstrTag -> ConstrDescription -> ClosureTypeInfo
+ SMRep: Constr :: ConTagZ -> ConstrDescription -> ClosureTypeInfo
- SimplEnv: DoneEx :: OutExpr -> SimplSR
+ SimplEnv: DoneEx :: OutExpr -> (Maybe JoinArity) -> SimplSR
- SimplEnv: SimplEnv :: SimplifierMode -> TvSubstEnv -> CvSubstEnv -> SimplIdSubst -> InScopeSet -> Floats -> JoinFloats -> SimplEnv
+ SimplEnv: SimplEnv :: SimplMode -> TvSubstEnv -> CvSubstEnv -> SimplIdSubst -> InScopeSet -> SimplEnv
- SimplEnv: [seMode] :: SimplEnv -> SimplifierMode
+ SimplEnv: [seMode] :: SimplEnv -> SimplMode
- SimplEnv: addFloats :: SimplEnv -> SimplEnv -> SimplEnv
+ SimplEnv: addFloats :: SimplFloats -> SimplFloats -> SimplFloats
- SimplEnv: doFloatFromRhs :: TopLevelFlag -> RecFlag -> Bool -> OutExpr -> SimplEnv -> Bool
+ SimplEnv: doFloatFromRhs :: TopLevelFlag -> RecFlag -> Bool -> SimplFloats -> OutExpr -> Bool
- SimplEnv: emptyFloats :: Floats
+ SimplEnv: emptyFloats :: SimplEnv -> SimplFloats
- SimplEnv: extendFloats :: SimplEnv -> OutBind -> SimplEnv
+ SimplEnv: extendFloats :: SimplFloats -> OutBind -> SimplFloats
- SimplEnv: getMode :: SimplEnv -> SimplifierMode
+ SimplEnv: getMode :: SimplEnv -> SimplMode
- SimplEnv: mkSimplEnv :: SimplifierMode -> SimplEnv
+ SimplEnv: mkSimplEnv :: SimplMode -> SimplEnv
- SimplEnv: setMode :: SimplifierMode -> SimplEnv -> SimplEnv
+ SimplEnv: setMode :: SimplMode -> SimplEnv -> SimplEnv
- SimplEnv: type JoinFloats = OrdList OutBind
+ SimplEnv: type JoinFloats = OrdList JoinFloat
- SimplEnv: updMode :: (SimplifierMode -> SimplifierMode) -> SimplEnv -> SimplEnv
+ SimplEnv: updMode :: (SimplMode -> SimplMode) -> SimplEnv -> SimplEnv
- SimplEnv: wrapFloats :: SimplEnv -> OutExpr -> OutExpr
+ SimplEnv: wrapFloats :: SimplFloats -> OutExpr -> OutExpr
- SimplEnv: wrapJoinFloats :: SimplEnv -> OutExpr -> OutExpr
+ SimplEnv: wrapJoinFloats :: JoinFloats -> OutExpr -> OutExpr
- SimplStg: stg2stg :: DynFlags -> Module -> [StgTopBinding] -> IO ([StgTopBinding], CollectedCCs)
+ SimplStg: stg2stg :: DynFlags -> [StgTopBinding] -> IO [StgTopBinding]
- SimplUtils: StrictArg :: ArgInfo -> CallCtxt -> SimplCont -> SimplCont
+ SimplUtils: StrictArg :: DupFlag -> ArgInfo -> CallCtxt -> SimplCont -> SimplCont
- SimplUtils: StrictBind :: InId -> [InBndr] -> InExpr -> StaticEnv -> SimplCont -> SimplCont
+ SimplUtils: StrictBind :: DupFlag -> InId -> [InBndr] -> InExpr -> StaticEnv -> SimplCont -> SimplCont
- SimplUtils: abstractFloats :: [OutTyVar] -> SimplEnv -> OutExpr -> SimplM ([OutBind], OutExpr)
+ SimplUtils: abstractFloats :: DynFlags -> TopLevelFlag -> [OutTyVar] -> SimplFloats -> OutExpr -> SimplM ([OutBind], OutExpr)
- SimplUtils: interestingCallContext :: SimplCont -> CallCtxt
+ SimplUtils: interestingCallContext :: SimplEnv -> SimplCont -> CallCtxt
- SimplUtils: postInlineUnconditionally :: DynFlags -> SimplEnv -> TopLevelFlag -> OutId -> OccInfo -> OutExpr -> Unfolding -> Bool
+ SimplUtils: postInlineUnconditionally :: SimplEnv -> TopLevelFlag -> OutId -> OccInfo -> OutExpr -> Bool
- SimplUtils: preInlineUnconditionally :: DynFlags -> SimplEnv -> TopLevelFlag -> InId -> InExpr -> Bool
+ SimplUtils: preInlineUnconditionally :: SimplEnv -> TopLevelFlag -> InId -> InExpr -> Bool
- SimplUtils: tryEtaExpandRhs :: SimplEnv -> RecFlag -> OutId -> OutExpr -> SimplM (Arity, OutExpr)
+ SimplUtils: tryEtaExpandRhs :: SimplMode -> OutId -> OutExpr -> SimplM (Arity, Bool, OutExpr)
- SimplUtils: updModeForRules :: SimplifierMode -> SimplifierMode
+ SimplUtils: updModeForRules :: SimplMode -> SimplMode
- SimplUtils: updModeForStableUnfoldings :: Activation -> SimplifierMode -> SimplifierMode
+ SimplUtils: updModeForStableUnfoldings :: Activation -> SimplMode -> SimplMode
- Simplify: simplTopBinds :: SimplEnv -> [InBind] -> SimplM SimplEnv
+ Simplify: simplTopBinds :: SimplEnv -> [InBind] -> SimplM (SimplFloats, SimplEnv)
- SpecConstr: data SpecConstrAnnotation :: *
+ SpecConstr: data SpecConstrAnnotation
- State: State :: (s -> (# a, s #)) -> State s a
+ State: State :: s -> (# a, s #) -> State s a
- StgLint: lintStgTopBindings :: String -> [StgTopBinding] -> [StgTopBinding]
+ StgLint: lintStgTopBindings :: Bool -> String -> [StgTopBinding] -> [StgTopBinding]
- TcAnnotations: annCtxt :: (OutputableBndrId id) => AnnDecl id -> SDoc
+ TcAnnotations: annCtxt :: (SourceTextX p, OutputableBndrId p) => AnnDecl p -> SDoc
- TcAnnotations: tcAnnotations :: [LAnnDecl Name] -> TcM [Annotation]
+ TcAnnotations: tcAnnotations :: [LAnnDecl GhcRn] -> TcM [Annotation]
- TcArrows: tcProc :: InPat Name -> LHsCmdTop Name -> ExpRhoType -> TcM (OutPat TcId, LHsCmdTop TcId, TcCoercion)
+ TcArrows: tcProc :: InPat GhcRn -> LHsCmdTop GhcRn -> ExpRhoType -> TcM (OutPat GhcTcId, LHsCmdTop GhcTcId, TcCoercion)
- TcBinds: addTypecheckedBinds :: TcGblEnv -> [LHsBinds Id] -> TcGblEnv
+ TcBinds: addTypecheckedBinds :: TcGblEnv -> [LHsBinds GhcTc] -> TcGblEnv
- TcBinds: tcHsBootSigs :: [(RecFlag, LHsBinds Name)] -> [LSig Name] -> TcM [Id]
+ TcBinds: tcHsBootSigs :: [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM [Id]
- TcBinds: tcLocalBinds :: HsLocalBinds Name -> TcM thing -> TcM (HsLocalBinds TcId, thing)
+ TcBinds: tcLocalBinds :: HsLocalBinds GhcRn -> TcM thing -> TcM (HsLocalBinds GhcTcId, thing)
- TcBinds: tcPolyCheck :: TcPragEnv -> TcIdSigInfo -> LHsBind Name -> TcM (LHsBinds TcId, [TcId])
+ TcBinds: tcPolyCheck :: TcPragEnv -> TcIdSigInfo -> LHsBind GhcRn -> TcM (LHsBinds GhcTcId, [TcId])
- TcBinds: tcRecSelBinds :: HsValBinds Name -> TcM TcGblEnv
+ TcBinds: tcRecSelBinds :: HsValBinds GhcRn -> TcM TcGblEnv
- TcBinds: tcTopBinds :: [(RecFlag, LHsBinds Name)] -> [LSig Name] -> TcM (TcGblEnv, TcLclEnv)
+ TcBinds: tcTopBinds :: [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM (TcGblEnv, TcLclEnv)
- TcBinds: tcVectDecls :: [LVectDecl Name] -> TcM ([LVectDecl TcId])
+ TcBinds: tcVectDecls :: [LVectDecl GhcRn] -> TcM ([LVectDecl GhcTcId])
- TcClassDcl: findMethodBind :: Name -> LHsBinds Name -> TcPragEnv -> Maybe (LHsBind Name, SrcSpan, [LSig Name])
+ TcClassDcl: findMethodBind :: Name -> LHsBinds GhcRn -> TcPragEnv -> Maybe (LHsBind GhcRn, SrcSpan, [LSig GhcRn])
- TcClassDcl: instantiateMethod :: Class -> Id -> [TcType] -> TcType
+ TcClassDcl: instantiateMethod :: Class -> TcId -> [TcType] -> TcType
- TcClassDcl: mkHsSigFun :: [LSig Name] -> HsSigFun
+ TcClassDcl: mkHsSigFun :: [LSig GhcRn] -> HsSigFun
- TcClassDcl: tcATDefault :: Bool -> SrcSpan -> TCvSubst -> NameSet -> ClassATItem -> TcM [FamInst]
+ TcClassDcl: tcATDefault :: SrcSpan -> TCvSubst -> NameSet -> ClassATItem -> TcM [FamInst]
- TcClassDcl: tcAddDeclCtxt :: TyClDecl Name -> TcM a -> TcM a
+ TcClassDcl: tcAddDeclCtxt :: TyClDecl GhcRn -> TcM a -> TcM a
- TcClassDcl: tcClassDecl2 :: LTyClDecl Name -> TcM (LHsBinds Id)
+ TcClassDcl: tcClassDecl2 :: LTyClDecl GhcRn -> TcM (LHsBinds GhcTcId)
- TcClassDcl: tcClassMinimalDef :: Name -> [LSig Name] -> [TcMethInfo] -> TcM ClassMinimalDef
+ TcClassDcl: tcClassMinimalDef :: Name -> [LSig GhcRn] -> [TcMethInfo] -> TcM ClassMinimalDef
- TcClassDcl: tcClassSigs :: Name -> [LSig Name] -> LHsBinds Name -> TcM [TcMethInfo]
+ TcClassDcl: tcClassSigs :: Name -> [LSig GhcRn] -> LHsBinds GhcRn -> TcM [TcMethInfo]
- TcClassDcl: tcMkDeclCtxt :: TyClDecl Name -> SDoc
+ TcClassDcl: tcMkDeclCtxt :: TyClDecl GhcRn -> SDoc
- TcClassDcl: type HsSigFun = Name -> Maybe (LHsSigType Name)
+ TcClassDcl: type HsSigFun = Name -> Maybe (LHsSigType GhcRn)
- TcDefaults: tcDefaults :: [LDefaultDecl Name] -> TcM (Maybe [Type])
+ TcDefaults: tcDefaults :: [LDefaultDecl GhcRn] -> TcM (Maybe [Type])
- TcDeriv: DerivInfo :: TyCon -> [LHsDerivingClause Name] -> SDoc -> DerivInfo
+ TcDeriv: DerivInfo :: TyCon -> [LHsDerivingClause GhcRn] -> SDoc -> DerivInfo
- TcDeriv: [di_clauses] :: DerivInfo -> [LHsDerivingClause Name]
+ TcDeriv: [di_clauses] :: DerivInfo -> [LHsDerivingClause GhcRn]
- TcDeriv: mkDerivInfos :: [LTyClDecl Name] -> TcM [DerivInfo]
+ TcDeriv: mkDerivInfos :: [LTyClDecl GhcRn] -> TcM [DerivInfo]
- TcDeriv: tcDeriving :: [DerivInfo] -> [LDerivDecl Name] -> TcM (TcGblEnv, Bag (InstInfo Name), HsValBinds Name)
+ TcDeriv: tcDeriving :: [DerivInfo] -> [LDerivDecl GhcRn] -> TcM (TcGblEnv, Bag (InstInfo GhcRn), HsValBinds GhcRn)
- TcDerivInfer: inferConstraints :: [TyVar] -> Class -> [TcType] -> TcType -> TyCon -> [TcType] -> DerivSpecMechanism -> TcM ([ThetaOrigin], [TyVar], [TcType])
+ TcDerivInfer: inferConstraints :: DerivSpecMechanism -> DerivM ([ThetaOrigin], [TyVar], [TcType])
- TcDerivUtils: DerivSpecStock :: (SrcSpan -> TyCon -> [Type] -> TcM (LHsBinds RdrName, BagDerivStuff)) -> DerivSpecMechanism
+ TcDerivUtils: DerivSpecStock :: (SrcSpan -> TyCon -> [Type] -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name])) -> DerivSpecMechanism
- TcDerivUtils: hasStockDeriving :: Class -> Maybe (SrcSpan -> TyCon -> [Type] -> TcM (LHsBinds RdrName, BagDerivStuff))
+ TcDerivUtils: hasStockDeriving :: Class -> Maybe (SrcSpan -> TyCon -> [Type] -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))
- TcEnv: getTypeSigNames :: [LSig Name] -> NameSet
+ TcEnv: getTypeSigNames :: [LSig GhcRn] -> NameSet
- TcEnv: pprInstInfoDetails :: (OutputableBndrId a) => InstInfo a -> SDoc
+ TcEnv: pprInstInfoDetails :: (SourceTextX a, OutputableBndrId a) => InstInfo a -> SDoc
- TcEnv: tcAddDataFamConPlaceholders :: [LInstDecl Name] -> TcM a -> TcM a
+ TcEnv: tcAddDataFamConPlaceholders :: [LInstDecl GhcRn] -> TcM a -> TcM a
- TcEnv: tcAddPatSynPlaceholders :: [PatSynBind Name Name] -> TcM a -> TcM a
+ TcEnv: tcAddPatSynPlaceholders :: [PatSynBind GhcRn GhcRn] -> TcM a -> TcM a
- TcEnv: tcExtendRules :: [LRuleDecl Id] -> TcM a -> TcM a
+ TcEnv: tcExtendRules :: [LRuleDecl GhcTc] -> TcM a -> TcM a
- TcExpr: addExprErrCtxt :: LHsExpr Name -> TcM a -> TcM a
+ TcExpr: addExprErrCtxt :: LHsExpr GhcRn -> TcM a -> TcM a
- TcExpr: tcCheckId :: Name -> ExpRhoType -> TcM (HsExpr TcId)
+ TcExpr: tcCheckId :: Name -> ExpRhoType -> TcM (HsExpr GhcTcId)
- TcExpr: tcInferRho :: LHsExpr Name -> TcM (LHsExpr TcId, TcRhoType)
+ TcExpr: tcInferRho :: LHsExpr GhcRn -> TcM (LHsExpr GhcTcId, TcRhoType)
- TcExpr: tcInferRhoNC :: LHsExpr Name -> TcM (LHsExpr TcId, TcRhoType)
+ TcExpr: tcInferRhoNC :: LHsExpr GhcRn -> TcM (LHsExpr GhcTcId, TcRhoType)
- TcExpr: tcInferSigma :: LHsExpr Name -> TcM (LHsExpr TcId, TcSigmaType)
+ TcExpr: tcInferSigma :: LHsExpr GhcRn -> TcM (LHsExpr GhcTcId, TcSigmaType)
- TcExpr: tcInferSigmaNC :: LHsExpr Name -> TcM (LHsExpr TcId, TcSigmaType)
+ TcExpr: tcInferSigmaNC :: LHsExpr GhcRn -> TcM (LHsExpr GhcTcId, TcSigmaType)
- TcExpr: tcMonoExpr :: LHsExpr Name -> ExpRhoType -> TcM (LHsExpr TcId)
+ TcExpr: tcMonoExpr :: LHsExpr GhcRn -> ExpRhoType -> TcM (LHsExpr GhcTcId)
- TcExpr: tcMonoExprNC :: LHsExpr Name -> ExpRhoType -> TcM (LHsExpr TcId)
+ TcExpr: tcMonoExprNC :: LHsExpr GhcRn -> ExpRhoType -> TcM (LHsExpr GhcTcId)
- TcExpr: tcPolyExpr :: LHsExpr Name -> TcSigmaType -> TcM (LHsExpr TcId)
+ TcExpr: tcPolyExpr :: LHsExpr GhcRn -> TcSigmaType -> TcM (LHsExpr GhcTcId)
- TcExpr: tcSyntaxOp :: CtOrigin -> SyntaxExpr Name -> [SyntaxOpType] -> ExpRhoType -> ([TcSigmaType] -> TcM a) -> TcM (a, SyntaxExpr TcId)
+ TcExpr: tcSyntaxOp :: CtOrigin -> SyntaxExpr GhcRn -> [SyntaxOpType] -> ExpRhoType -> ([TcSigmaType] -> TcM a) -> TcM (a, SyntaxExpr GhcTcId)
- TcExpr: tcSyntaxOpGen :: CtOrigin -> SyntaxExpr Name -> [SyntaxOpType] -> SyntaxOpType -> ([TcSigmaType] -> TcM a) -> TcM (a, SyntaxExpr TcId)
+ TcExpr: tcSyntaxOpGen :: CtOrigin -> SyntaxExpr GhcRn -> [SyntaxOpType] -> SyntaxOpType -> ([TcSigmaType] -> TcM a) -> TcM (a, SyntaxExpr GhcTcId)
- TcForeign: tcFExport :: ForeignDecl Name -> TcM (LHsBind Id, ForeignDecl Id, Bag GlobalRdrElt)
+ TcForeign: tcFExport :: ForeignDecl GhcRn -> TcM (LHsBind GhcTc, ForeignDecl GhcTc, Bag GlobalRdrElt)
- TcForeign: tcFImport :: LForeignDecl Name -> TcM (Id, LForeignDecl Id, Bag GlobalRdrElt)
+ TcForeign: tcFImport :: LForeignDecl GhcRn -> TcM (Id, LForeignDecl GhcTc, Bag GlobalRdrElt)
- TcForeign: tcForeignExports :: [LForeignDecl Name] -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt)
+ TcForeign: tcForeignExports :: [LForeignDecl GhcRn] -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt)
- TcForeign: tcForeignExports' :: [LForeignDecl Name] -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt)
+ TcForeign: tcForeignExports' :: [LForeignDecl GhcRn] -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt)
- TcForeign: tcForeignImports :: [LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt)
+ TcForeign: tcForeignImports :: [LForeignDecl GhcRn] -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt)
- TcForeign: tcForeignImports' :: [LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt)
+ TcForeign: tcForeignImports' :: [LForeignDecl GhcRn] -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt)
- TcGenDeriv: DerivHsBind :: (LHsBind RdrName, LSig RdrName) -> DerivStuff
+ TcGenDeriv: DerivHsBind :: (LHsBind GhcPs, LSig GhcPs) -> DerivStuff
- TcGenDeriv: error_Expr :: String -> LHsExpr RdrName
+ TcGenDeriv: error_Expr :: String -> LHsExpr GhcPs
- TcGenDeriv: gen_Bounded_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Bounded_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Data_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Data_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Enum_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Enum_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Eq_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Eq_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Ix_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Ix_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Lift_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Lift_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Newtype_binds :: SrcSpan -> Class -> [TyVar] -> [Type] -> Type -> TcM (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Newtype_binds :: SrcSpan -> Class -> [TyVar] -> [Type] -> Type -> TcM (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Ord_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Ord_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Read_binds :: (Name -> Fixity) -> SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Read_binds :: (Name -> Fixity) -> SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: gen_Show_binds :: (Name -> Fixity) -> SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
+ TcGenDeriv: gen_Show_binds :: (Name -> Fixity) -> SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)
- TcGenDeriv: litConTbl :: [(Type, LHsExpr RdrName -> LHsExpr RdrName)]
+ TcGenDeriv: litConTbl :: [(Type, LHsExpr GhcPs -> LHsExpr GhcPs)]
- TcGenDeriv: mkRdrFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> LHsBind RdrName
+ TcGenDeriv: mkRdrFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsBind GhcPs
- TcGenFunctor: FT :: a -> a -> a -> (a -> a -> a) -> (TyCon -> [a] -> a) -> (Type -> a -> a) -> a -> (TcTyVar -> a -> a) -> FFoldType a
+ TcGenFunctor: FT :: a -> a -> a -> a -> a -> a -> TyCon -> [a] -> a -> Type -> a -> a -> a -> TcTyVar -> a -> a -> FFoldType a
- TcGenFunctor: gen_Foldable_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
+ TcGenFunctor: gen_Foldable_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)
- TcGenFunctor: gen_Functor_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
+ TcGenFunctor: gen_Functor_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)
- TcGenFunctor: gen_Traversable_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)
+ TcGenFunctor: gen_Traversable_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)
- TcGenGenerics: gen_Generic_binds :: GenericKind -> TyCon -> [Type] -> TcM (LHsBinds RdrName, FamInst)
+ TcGenGenerics: gen_Generic_binds :: GenericKind -> TyCon -> [Type] -> TcM (LHsBinds GhcPs, FamInst)
- TcHsSyn: hsLPatType :: OutPat Id -> Type
+ TcHsSyn: hsLPatType :: OutPat GhcTc -> Type
- TcHsSyn: hsLitType :: HsLit -> TcType
+ TcHsSyn: hsLitType :: HsLit p -> TcType
- TcHsSyn: hsPatType :: Pat Id -> Type
+ TcHsSyn: hsPatType :: Pat GhcTc -> Type
- TcHsSyn: mkHsAppTy :: LHsType name -> LHsType name -> LHsType name
+ TcHsSyn: mkHsAppTy :: LHsType pass -> LHsType pass -> LHsType pass
- TcHsSyn: mkHsDictLet :: TcEvBinds -> LHsExpr Id -> LHsExpr Id
+ TcHsSyn: mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc
- TcHsSyn: shortCutLit :: DynFlags -> OverLitVal -> TcType -> Maybe (HsExpr TcId)
+ TcHsSyn: shortCutLit :: DynFlags -> OverLitVal -> TcType -> Maybe (HsExpr GhcTcId)
- TcHsSyn: zonkTopDecls :: Bag EvBind -> LHsBinds TcId -> [LRuleDecl TcId] -> [LVectDecl TcId] -> [LTcSpecPrag] -> [LForeignDecl TcId] -> TcM (TypeEnv, Bag EvBind, LHsBinds Id, [LForeignDecl Id], [LTcSpecPrag], [LRuleDecl Id], [LVectDecl Id])
+ TcHsSyn: zonkTopDecls :: Bag EvBind -> LHsBinds GhcTcId -> [LRuleDecl GhcTcId] -> [LVectDecl GhcTcId] -> [LTcSpecPrag] -> [LForeignDecl GhcTcId] -> TcM (TypeEnv, Bag EvBind, LHsBinds GhcTc, [LForeignDecl GhcTc], [LTcSpecPrag], [LRuleDecl GhcTc], [LVectDecl GhcTc])
- TcHsSyn: zonkTopExpr :: HsExpr TcId -> TcM (HsExpr Id)
+ TcHsSyn: zonkTopExpr :: HsExpr GhcTcId -> TcM (HsExpr GhcTc)
- TcHsSyn: zonkTopLExpr :: LHsExpr TcId -> TcM (LHsExpr Id)
+ TcHsSyn: zonkTopLExpr :: LHsExpr GhcTcId -> TcM (LHsExpr GhcTc)
- TcHsType: addSigCtxt :: UserTypeCtxt -> LHsType Name -> TcM a -> TcM a
+ TcHsType: addSigCtxt :: UserTypeCtxt -> LHsType GhcRn -> TcM a -> TcM a
- TcHsType: kcHsSigType :: [Located Name] -> LHsSigType Name -> TcM ()
+ TcHsType: kcHsSigType :: [Located Name] -> LHsSigType GhcRn -> TcM ()
- TcHsType: pprSigCtxt :: UserTypeCtxt -> LHsType Name -> SDoc
+ TcHsType: pprSigCtxt :: UserTypeCtxt -> LHsType GhcRn -> SDoc
- TcHsType: tcCheckLHsType :: LHsType Name -> Kind -> TcM Type
+ TcHsType: tcCheckLHsType :: LHsType GhcRn -> Kind -> TcM TcType
- TcHsType: tcClassSigType :: [Located Name] -> LHsSigType Name -> TcM Type
+ TcHsType: tcClassSigType :: [Located Name] -> LHsSigType GhcRn -> TcM Type
- TcHsType: tcDataKindSig :: Kind -> TcM ([TyConBinder], Kind)
+ TcHsType: tcDataKindSig :: DataKindCheck -> Kind -> TcM ([TyConBinder], Kind)
- TcHsType: tcExplicitTKBndrs :: [LHsTyVarBndr Name] -> ([TyVar] -> TcM (a, TyVarSet)) -> TcM (a, TyVarSet)
+ TcHsType: tcExplicitTKBndrs :: [LHsTyVarBndr GhcRn] -> ([TyVar] -> TcM (a, TyVarSet)) -> TcM (a, TyVarSet)
- TcHsType: tcHsClsInstType :: UserTypeCtxt -> LHsSigType Name -> TcM ([TyVar], ThetaType, Class, [Type])
+ TcHsType: tcHsClsInstType :: UserTypeCtxt -> LHsSigType GhcRn -> TcM ([TyVar], ThetaType, Class, [Type])
- TcHsType: tcHsContext :: LHsContext Name -> TcM [PredType]
+ TcHsType: tcHsContext :: LHsContext GhcRn -> TcM [PredType]
- TcHsType: tcHsDeriv :: LHsSigType Name -> TcM ([TyVar], Class, [Type], [Kind])
+ TcHsType: tcHsDeriv :: LHsSigType GhcRn -> TcM ([TyVar], Class, [Type], [Kind])
- TcHsType: tcHsLiftedType :: LHsType Name -> TcM TcType
+ TcHsType: tcHsLiftedType :: LHsType GhcRn -> TcM TcType
- TcHsType: tcHsLiftedTypeNC :: LHsType Name -> TcM TcType
+ TcHsType: tcHsLiftedTypeNC :: LHsType GhcRn -> TcM TcType
- TcHsType: tcHsOpenType :: LHsType Name -> TcM TcType
+ TcHsType: tcHsOpenType :: LHsType GhcRn -> TcM TcType
- TcHsType: tcHsOpenTypeNC :: LHsType Name -> TcM TcType
+ TcHsType: tcHsOpenTypeNC :: LHsType GhcRn -> TcM TcType
- TcHsType: tcHsPartialSigType :: UserTypeCtxt -> LHsSigWcType Name -> TcM ([(Name, TcTyVar)], Maybe TcTyVar, [TcTyVar], TcThetaType, TcType)
+ TcHsType: tcHsPartialSigType :: UserTypeCtxt -> LHsSigWcType GhcRn -> TcM ([(Name, TcTyVar)], Maybe TcTyVar, [TcTyVar], TcThetaType, TcType)
- TcHsType: tcHsPatSigType :: UserTypeCtxt -> LHsSigWcType Name -> TcM ([(Name, TcTyVar)], [(Name, TcTyVar)], TcType)
+ TcHsType: tcHsPatSigType :: UserTypeCtxt -> LHsSigWcType GhcRn -> TcM ([(Name, TcTyVar)], [(Name, TcTyVar)], TcType)
- TcHsType: tcHsSigType :: UserTypeCtxt -> LHsSigType Name -> TcM Type
+ TcHsType: tcHsSigType :: UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
- TcHsType: tcHsSigWcType :: UserTypeCtxt -> LHsSigWcType Name -> TcM Type
+ TcHsType: tcHsSigWcType :: UserTypeCtxt -> LHsSigWcType GhcRn -> TcM Type
- TcHsType: tcHsTypeApp :: LHsWcType Name -> Kind -> TcM Type
+ TcHsType: tcHsTypeApp :: LHsWcType GhcRn -> Kind -> TcM Type
- TcHsType: tcHsVectInst :: LHsSigType Name -> TcM (Class, [Type])
+ TcHsType: tcHsVectInst :: LHsSigType GhcRn -> TcM (Class, [Type])
- TcHsType: tcInferApps :: Outputable fun => TcTyMode -> fun -> TcType -> TcKind -> [LHsType Name] -> TcM (TcType, TcKind)
+ TcHsType: tcInferApps :: TcTyMode -> Maybe (VarEnv Kind) -> LHsType GhcRn -> TcType -> TcKind -> [LHsType GhcRn] -> TcM (TcType, [TcType], TcKind)
- TcHsType: tcLHsKindSig :: LHsKind Name -> TcM Kind
+ TcHsType: tcLHsKindSig :: LHsKind GhcRn -> TcM Kind
- TcHsType: tcLHsPredType :: LHsType Name -> TcM PredType
+ TcHsType: tcLHsPredType :: LHsType GhcRn -> TcM PredType
- TcHsType: tcLHsType :: LHsType Name -> TcM (TcType, TcKind)
+ TcHsType: tcLHsType :: LHsType GhcRn -> TcM (TcType, TcKind)
- TcHsType: tcPatSig :: Bool -> LHsSigWcType Name -> ExpSigmaType -> TcM (TcType, [(Name, TcTyVar)], [(Name, TcTyVar)], HsWrapper)
+ TcHsType: tcPatSig :: Bool -> LHsSigWcType GhcRn -> ExpSigmaType -> TcM (TcType, [(Name, TcTyVar)], [(Name, TcTyVar)], HsWrapper)
- TcInstDcls: tcInstDecls1 :: [LInstDecl Name] -> TcM (TcGblEnv, [InstInfo Name], [DerivInfo])
+ TcInstDcls: tcInstDecls1 :: [LInstDecl GhcRn] -> TcM (TcGblEnv, [InstInfo GhcRn], [DerivInfo])
- TcInstDcls: tcInstDecls2 :: [LTyClDecl Name] -> [InstInfo Name] -> TcM (LHsBinds Id)
+ TcInstDcls: tcInstDecls2 :: [LTyClDecl GhcRn] -> [InstInfo GhcRn] -> TcM (LHsBinds GhcTc)
- TcInstDcls: tcInstDeclsDeriv :: [DerivInfo] -> [LTyClDecl Name] -> [LDerivDecl Name] -> TcM (TcGblEnv, [InstInfo Name], HsValBinds Name)
+ TcInstDcls: tcInstDeclsDeriv :: [DerivInfo] -> [LTyClDecl GhcRn] -> [LDerivDecl GhcRn] -> TcM (TcGblEnv, [InstInfo GhcRn], HsValBinds GhcRn)
- TcMType: checkCoercionHole :: Coercion -> CoercionHole -> Role -> Type -> Type -> TcM Coercion
+ TcMType: checkCoercionHole :: CoVar -> Coercion -> TcM Coercion
- TcMType: instSkolTyCoVars :: TcTyVarMaker -> [TyVar] -> TcRnIf gbl lcl (TCvSubst, [TyCoVar])
+ TcMType: instSkolTyCoVars :: TcTyCoVarMaker gbl lcl -> [TyVar] -> TcRnIf gbl lcl (TCvSubst, [TyCoVar])
- TcMType: newCoercionHole :: TcM CoercionHole
+ TcMType: newCoercionHole :: TcPredType -> TcM CoercionHole
- TcMType: zonkQuantifiedTyVar :: Bool -> TcTyVar -> TcM (Maybe TcTyVar)
+ TcMType: zonkQuantifiedTyVar :: TcTyVar -> TcM TcTyVar
- TcMatches: MC :: HsMatchContext Name -> (Located (body Name) -> ExpRhoType -> TcM (Located (body TcId))) -> TcMatchCtxt body
+ TcMatches: MC :: HsMatchContext Name -> Located (body GhcRn) -> ExpRhoType -> TcM (Located (body GhcTcId)) -> TcMatchCtxt body
- TcMatches: [mc_body] :: TcMatchCtxt body -> Located (body Name) -> ExpRhoType -> TcM (Located (body TcId))
+ TcMatches: [mc_body] :: TcMatchCtxt body -> Located (body GhcRn) -> ExpRhoType -> TcM (Located (body GhcTcId))
- TcMatches: tcBody :: LHsExpr Name -> ExpRhoType -> TcM (LHsExpr TcId)
+ TcMatches: tcBody :: LHsExpr GhcRn -> ExpRhoType -> TcM (LHsExpr GhcTcId)
- TcMatches: tcDoStmts :: HsStmtContext Name -> Located [LStmt Name (LHsExpr Name)] -> ExpRhoType -> TcM (HsExpr TcId)
+ TcMatches: tcDoStmts :: HsStmtContext Name -> Located [LStmt GhcRn (LHsExpr GhcRn)] -> ExpRhoType -> TcM (HsExpr GhcTcId)
- TcMatches: tcGRHS :: TcMatchCtxt body -> ExpRhoType -> GRHS Name (Located (body Name)) -> TcM (GRHS TcId (Located (body TcId)))
+ TcMatches: tcGRHS :: TcMatchCtxt body -> ExpRhoType -> GRHS GhcRn (Located (body GhcRn)) -> TcM (GRHS GhcTcId (Located (body GhcTcId)))
- TcMatches: tcGRHSsPat :: GRHSs Name (LHsExpr Name) -> TcRhoType -> TcM (GRHSs TcId (LHsExpr TcId))
+ TcMatches: tcGRHSsPat :: GRHSs GhcRn (LHsExpr GhcRn) -> TcRhoType -> TcM (GRHSs GhcTcId (LHsExpr GhcTcId))
- TcMatches: tcMatchLambda :: SDoc -> TcMatchCtxt HsExpr -> MatchGroup Name (LHsExpr Name) -> ExpRhoType -> TcM (MatchGroup TcId (LHsExpr TcId), HsWrapper)
+ TcMatches: tcMatchLambda :: SDoc -> TcMatchCtxt HsExpr -> MatchGroup GhcRn (LHsExpr GhcRn) -> ExpRhoType -> TcM (MatchGroup GhcTcId (LHsExpr GhcTcId), HsWrapper)
- TcMatches: tcMatchesCase :: (Outputable (body Name)) => TcMatchCtxt body -> TcSigmaType -> MatchGroup Name (Located (body Name)) -> ExpRhoType -> TcM (MatchGroup TcId (Located (body TcId)))
+ TcMatches: tcMatchesCase :: (Outputable (body GhcRn)) => TcMatchCtxt body -> TcSigmaType -> MatchGroup GhcRn (Located (body GhcRn)) -> ExpRhoType -> TcM (MatchGroup GhcTcId (Located (body GhcTcId)))
- TcMatches: tcMatchesFun :: Located Name -> MatchGroup Name (LHsExpr Name) -> ExpRhoType -> TcM (HsWrapper, MatchGroup TcId (LHsExpr TcId))
+ TcMatches: tcMatchesFun :: Located Name -> MatchGroup GhcRn (LHsExpr GhcRn) -> ExpRhoType -> TcM (HsWrapper, MatchGroup GhcTcId (LHsExpr GhcTcId))
- TcMatches: tcStmts :: (Outputable (body Name)) => HsStmtContext Name -> TcStmtChecker body rho_type -> [LStmt Name (Located (body Name))] -> rho_type -> TcM [LStmt TcId (Located (body TcId))]
+ TcMatches: tcStmts :: (Outputable (body GhcRn)) => HsStmtContext Name -> TcStmtChecker body rho_type -> [LStmt GhcRn (Located (body GhcRn))] -> rho_type -> TcM [LStmt GhcTcId (Located (body GhcTcId))]
- TcMatches: tcStmtsAndThen :: (Outputable (body Name)) => HsStmtContext Name -> TcStmtChecker body rho_type -> [LStmt Name (Located (body Name))] -> rho_type -> (rho_type -> TcM thing) -> TcM ([LStmt TcId (Located (body TcId))], thing)
+ TcMatches: tcStmtsAndThen :: (Outputable (body GhcRn)) => HsStmtContext Name -> TcStmtChecker body rho_type -> [LStmt GhcRn (Located (body GhcRn))] -> rho_type -> (rho_type -> TcM thing) -> TcM ([LStmt GhcTcId (Located (body GhcTcId))], thing)
- TcMatches: type TcStmtChecker body rho_type = forall thing. HsStmtContext Name -> Stmt Name (Located (body Name)) -> rho_type -> (rho_type -> TcM thing) -> TcM (Stmt TcId (Located (body TcId)), thing)
+ TcMatches: type TcStmtChecker body rho_type = forall thing. HsStmtContext Name -> Stmt GhcRn (Located (body GhcRn)) -> rho_type -> (rho_type -> TcM thing) -> TcM (Stmt GhcTcId (Located (body GhcTcId)), thing)
- TcPat: tcLetPat :: (Name -> Maybe TcId) -> LetBndrSpec -> LPat Name -> ExpSigmaType -> TcM a -> TcM (LPat TcId, a)
+ TcPat: tcLetPat :: (Name -> Maybe TcId) -> LetBndrSpec -> LPat GhcRn -> ExpSigmaType -> TcM a -> TcM (LPat GhcTcId, a)
- TcPat: tcPat :: HsMatchContext Name -> LPat Name -> ExpSigmaType -> TcM a -> TcM (LPat TcId, a)
+ TcPat: tcPat :: HsMatchContext Name -> LPat GhcRn -> ExpSigmaType -> TcM a -> TcM (LPat GhcTcId, a)
- TcPat: tcPat_O :: HsMatchContext Name -> CtOrigin -> LPat Name -> ExpSigmaType -> TcM a -> TcM (LPat TcId, a)
+ TcPat: tcPat_O :: HsMatchContext Name -> CtOrigin -> LPat GhcRn -> ExpSigmaType -> TcM a -> TcM (LPat GhcTcId, a)
- TcPat: tcPats :: HsMatchContext Name -> [LPat Name] -> [ExpSigmaType] -> TcM a -> TcM ([LPat TcId], a)
+ TcPat: tcPats :: HsMatchContext Name -> [LPat GhcRn] -> [ExpSigmaType] -> TcM a -> TcM ([LPat GhcTcId], a)
- TcPatSyn: tcCheckPatSynDecl :: PatSynBind Name Name -> TcPatSynInfo -> TcM (LHsBinds Id, TcGblEnv)
+ TcPatSyn: tcCheckPatSynDecl :: PatSynBind GhcRn GhcRn -> TcPatSynInfo -> TcM (LHsBinds GhcTc, TcGblEnv)
- TcPatSyn: tcInferPatSynDecl :: PatSynBind Name Name -> TcM (LHsBinds Id, TcGblEnv)
+ TcPatSyn: tcInferPatSynDecl :: PatSynBind GhcRn GhcRn -> TcM (LHsBinds GhcTc, TcGblEnv)
- TcPatSyn: tcPatSynBuilderBind :: PatSynBind Name Name -> TcM (LHsBinds Id)
+ TcPatSyn: tcPatSynBuilderBind :: PatSynBind GhcRn GhcRn -> TcM (LHsBinds GhcTc)
- TcPatSyn: tcPatSynBuilderOcc :: PatSyn -> TcM (HsExpr TcId, TcSigmaType)
+ TcPatSyn: tcPatSynBuilderOcc :: PatSyn -> TcM (HsExpr GhcTcId, TcSigmaType)
- TcRnDriver: rnTopSrcDecls :: HsGroup RdrName -> TcM (TcGblEnv, HsGroup Name)
+ TcRnDriver: rnTopSrcDecls :: HsGroup GhcPs -> TcM (TcGblEnv, HsGroup GhcRn)
- TcRnDriver: tcRnDeclsi :: HscEnv -> [LHsDecl RdrName] -> IO (Messages, Maybe TcGblEnv)
+ TcRnDriver: tcRnDeclsi :: HscEnv -> [LHsDecl GhcPs] -> IO (Messages, Maybe TcGblEnv)
- TcRnDriver: tcRnExpr :: HscEnv -> TcRnExprMode -> LHsExpr RdrName -> IO (Messages, Maybe Type)
+ TcRnDriver: tcRnExpr :: HscEnv -> TcRnExprMode -> LHsExpr GhcPs -> IO (Messages, Maybe Type)
- TcRnDriver: tcRnGetInfo :: HscEnv -> Name -> IO (Messages, Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
+ TcRnDriver: tcRnGetInfo :: HscEnv -> Name -> IO (Messages, Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))
- TcRnDriver: tcRnImportDecls :: HscEnv -> [LImportDecl RdrName] -> IO (Messages, Maybe GlobalRdrEnv)
+ TcRnDriver: tcRnImportDecls :: HscEnv -> [LImportDecl GhcPs] -> IO (Messages, Maybe GlobalRdrEnv)
- TcRnDriver: tcRnStmt :: HscEnv -> GhciLStmt RdrName -> IO (Messages, Maybe ([Id], LHsExpr Id, FixityEnv))
+ TcRnDriver: tcRnStmt :: HscEnv -> GhciLStmt GhcPs -> IO (Messages, Maybe ([Id], LHsExpr GhcTc, FixityEnv))
- TcRnDriver: tcRnType :: HscEnv -> Bool -> LHsType RdrName -> IO (Messages, Maybe (Type, Kind))
+ TcRnDriver: tcRnType :: HscEnv -> Bool -> LHsType GhcPs -> IO (Messages, Maybe (Type, Kind))
- TcRnDriver: tcTopSrcDecls :: HsGroup Name -> TcM (TcGblEnv, TcLclEnv)
+ TcRnDriver: tcTopSrcDecls :: HsGroup GhcRn -> TcM (TcGblEnv, TcLclEnv)
- TcRnExports: exports_from_avail :: Maybe (Located [LIE RdrName]) -> GlobalRdrEnv -> ImportAvails -> Module -> RnM (Maybe [LIE Name], [AvailInfo])
+ TcRnExports: exports_from_avail :: Maybe (Located [LIE GhcPs]) -> GlobalRdrEnv -> ImportAvails -> Module -> RnM (Maybe [(LIE GhcRn, Avails)], Avails)
- TcRnExports: tcRnExports :: Bool -> Maybe (Located [LIE RdrName]) -> TcGblEnv -> RnM TcGblEnv
+ TcRnExports: tcRnExports :: Bool -> Maybe (Located [LIE GhcPs]) -> TcGblEnv -> RnM TcGblEnv
- TcRnMonad: warnIf :: WarnReason -> Bool -> MsgDoc -> TcRn ()
+ TcRnMonad: warnIf :: Bool -> MsgDoc -> TcRn ()
- TcRnTypes: ArithSeqOrigin :: (ArithSeqInfo Name) -> CtOrigin
+ TcRnTypes: ArithSeqOrigin :: (ArithSeqInfo GhcRn) -> CtOrigin
- TcRnTypes: DoPatOrigin :: (LPat Name) -> CtOrigin
+ TcRnTypes: DoPatOrigin :: (LPat GhcRn) -> CtOrigin
- TcRnTypes: DsSplice :: (HsExpr Id) -> DsMetaVal
+ TcRnTypes: DsSplice :: (HsExpr GhcTc) -> DsMetaVal
- TcRnTypes: FailablePattern :: (LPat TcId) -> CtOrigin
+ TcRnTypes: FailablePattern :: (LPat GhcTcId) -> CtOrigin
- TcRnTypes: IC_Solved :: VarSet -> [EvVar] -> ImplicStatus
+ TcRnTypes: IC_Solved :: [EvVar] -> ImplicStatus
- TcRnTypes: Implic :: TcLevel -> [TcTyVar] -> SkolemInfo -> [EvVar] -> Bool -> TcLclEnv -> WantedConstraints -> EvBindsVar -> VarSet -> ImplicStatus -> Implication
+ TcRnTypes: Implic :: TcLevel -> [TcTyVar] -> SkolemInfo -> [EvVar] -> Bool -> TcLclEnv -> WantedConstraints -> EvBindsVar -> VarSet -> VarSet -> ImplicStatus -> Implication
- TcRnTypes: LiteralOrigin :: (HsOverLit Name) -> CtOrigin
+ TcRnTypes: LiteralOrigin :: (HsOverLit GhcRn) -> CtOrigin
- TcRnTypes: MCompPatOrigin :: (LPat Name) -> CtOrigin
+ TcRnTypes: MCompPatOrigin :: (LPat GhcRn) -> CtOrigin
- TcRnTypes: PArrSeqOrigin :: (ArithSeqInfo Name) -> CtOrigin
+ TcRnTypes: PArrSeqOrigin :: (ArithSeqInfo GhcRn) -> CtOrigin
- TcRnTypes: PartialSig :: Name -> LHsSigWcType Name -> UserTypeCtxt -> SrcSpan -> TcIdSigInfo
+ TcRnTypes: PartialSig :: Name -> LHsSigWcType GhcRn -> UserTypeCtxt -> SrcSpan -> TcIdSigInfo
- TcRnTypes: ProvCtxtOrigin :: (PatSynBind Name Name) -> CtOrigin
+ TcRnTypes: ProvCtxtOrigin :: (PatSynBind GhcRn GhcRn) -> CtOrigin
- TcRnTypes: TcGblEnv :: Module -> Module -> HscSource -> GlobalRdrEnv -> Maybe [Type] -> FixityEnv -> RecFieldEnv -> TypeEnv -> TcRef TypeEnv -> InstEnv -> FamInstEnv -> AnnEnv -> NameEnv [([FamInst], FamInstEnv)] -> [AvailInfo] -> ImportAvails -> DefUses -> TcRef [GlobalRdrElt] -> TcRef NameSet -> TcRef Bool -> TcRef Bool -> TcRef (Set RealSrcSpan) -> TcRef OccSet -> [(Module, Fingerprint)] -> Maybe [Located (IE Name)] -> [LImportDecl Name] -> Maybe (HsGroup Name) -> TcRef [FilePath] -> TcRef [LHsDecl RdrName] -> TcRef [(ForeignSrcLang, String)] -> TcRef NameSet -> TcRef [TcM ()] -> TcRef (Map TypeRep Dynamic) -> TcRef (Maybe (ForeignRef (IORef QState))) -> Bag EvBind -> Maybe Id -> LHsBinds Id -> NameSet -> [LTcSpecPrag] -> Warnings -> [Annotation] -> [TyCon] -> [ClsInst] -> [FamInst] -> [LRuleDecl Id] -> [LForeignDecl Id] -> [LVectDecl Id] -> [PatSyn] -> Maybe LHsDocString -> AnyHpcUsage -> SelfBootInfo -> Maybe Name -> TcRef (Bool, WarningMessages) -> [TcPluginSolver] -> RealSrcSpan -> TcRef WantedConstraints -> [CompleteMatch] -> TcGblEnv
+ TcRnTypes: TcGblEnv :: Module -> Module -> HscSource -> GlobalRdrEnv -> Maybe [Type] -> FixityEnv -> RecFieldEnv -> TypeEnv -> TcRef TypeEnv -> InstEnv -> FamInstEnv -> AnnEnv -> [AvailInfo] -> ImportAvails -> DefUses -> TcRef [GlobalRdrElt] -> TcRef NameSet -> TcRef Bool -> TcRef Bool -> TcRef (Set RealSrcSpan) -> TcRef OccSet -> [(Module, Fingerprint)] -> Maybe [(Located (IE GhcRn), Avails)] -> [LImportDecl GhcRn] -> Maybe (HsGroup GhcRn) -> TcRef [FilePath] -> TcRef [LHsDecl GhcPs] -> TcRef [(ForeignSrcLang, String)] -> TcRef NameSet -> TcRef [TcM ()] -> TcRef [String] -> TcRef (Map TypeRep Dynamic) -> TcRef (Maybe (ForeignRef (IORef QState))) -> Bag EvBind -> Maybe Id -> LHsBinds GhcTc -> NameSet -> [LTcSpecPrag] -> Warnings -> [Annotation] -> [TyCon] -> [ClsInst] -> [FamInst] -> [LRuleDecl GhcTc] -> [LForeignDecl GhcTc] -> [LVectDecl GhcTc] -> [PatSyn] -> Maybe LHsDocString -> AnyHpcUsage -> SelfBootInfo -> Maybe Name -> TcRef (Bool, WarningMessages) -> [TcPluginSolver] -> RealSrcSpan -> TcRef WantedConstraints -> [CompleteMatch] -> TcGblEnv
- TcRnTypes: TcIdBndr :: TcId -> TopLevelFlag -> TcIdBinder
+ TcRnTypes: TcIdBndr :: TcId -> TopLevelFlag -> TcBinder
- TcRnTypes: TcIdBndr_ExpType :: Name -> ExpType -> TopLevelFlag -> TcIdBinder
+ TcRnTypes: TcIdBndr_ExpType :: Name -> ExpType -> TopLevelFlag -> TcBinder
- TcRnTypes: TcLclEnv :: RealSrcSpan -> [ErrCtxt] -> TcLevel -> ThStage -> ThBindEnv -> ArrowCtxt -> LocalRdrEnv -> TcTypeEnv -> TcIdBinderStack -> TidyEnv -> TcRef TcTyVarSet -> TcRef WantedConstraints -> TcRef Messages -> TcLclEnv
+ TcRnTypes: TcLclEnv :: RealSrcSpan -> [ErrCtxt] -> TcLevel -> ThStage -> ThBindEnv -> ArrowCtxt -> LocalRdrEnv -> TcTypeEnv -> TcBinderStack -> TcRef TcTyVarSet -> TcRef WantedConstraints -> TcRef Messages -> TcLclEnv
- TcRnTypes: TcPlugin :: TcPluginM s -> (s -> TcPluginSolver) -> (s -> TcPluginM ()) -> TcPlugin
+ TcRnTypes: TcPlugin :: TcPluginM s -> s -> TcPluginSolver -> s -> TcPluginM () -> TcPlugin
- TcRnTypes: TypeEqOrigin :: TcType -> TcType -> Maybe ErrorThing -> CtOrigin
+ TcRnTypes: TypeEqOrigin :: TcType -> TcType -> Maybe SDoc -> Bool -> CtOrigin
- TcRnTypes: WC :: Cts -> Bag Implication -> Cts -> WantedConstraints
+ TcRnTypes: WC :: Cts -> Bag Implication -> WantedConstraints
- TcRnTypes: [psig_hs_ty] :: TcIdSigInfo -> LHsSigWcType Name
+ TcRnTypes: [psig_hs_ty] :: TcIdSigInfo -> LHsSigWcType GhcRn
- TcRnTypes: [tcg_binds] :: TcGblEnv -> LHsBinds Id
+ TcRnTypes: [tcg_binds] :: TcGblEnv -> LHsBinds GhcTc
- TcRnTypes: [tcg_fords] :: TcGblEnv -> [LForeignDecl Id]
+ TcRnTypes: [tcg_fords] :: TcGblEnv -> [LForeignDecl GhcTc]
- TcRnTypes: [tcg_rn_decls] :: TcGblEnv -> Maybe (HsGroup Name)
+ TcRnTypes: [tcg_rn_decls] :: TcGblEnv -> Maybe (HsGroup GhcRn)
- TcRnTypes: [tcg_rn_exports] :: TcGblEnv -> Maybe [Located (IE Name)]
+ TcRnTypes: [tcg_rn_exports] :: TcGblEnv -> Maybe [(Located (IE GhcRn), Avails)]
- TcRnTypes: [tcg_rn_imports] :: TcGblEnv -> [LImportDecl Name]
+ TcRnTypes: [tcg_rn_imports] :: TcGblEnv -> [LImportDecl GhcRn]
- TcRnTypes: [tcg_rules] :: TcGblEnv -> [LRuleDecl Id]
+ TcRnTypes: [tcg_rules] :: TcGblEnv -> [LRuleDecl GhcTc]
- TcRnTypes: [tcg_th_topdecls] :: TcGblEnv -> TcRef [LHsDecl RdrName]
+ TcRnTypes: [tcg_th_topdecls] :: TcGblEnv -> TcRef [LHsDecl GhcPs]
- TcRnTypes: [tcg_vects] :: TcGblEnv -> [LVectDecl Id]
+ TcRnTypes: [tcg_vects] :: TcGblEnv -> [LVectDecl GhcTc]
- TcRnTypes: [tcl_bndrs] :: TcLclEnv -> TcIdBinderStack
+ TcRnTypes: [tcl_bndrs] :: TcLclEnv -> TcBinderStack
- TcRnTypes: [uo_thing] :: CtOrigin -> Maybe ErrorThing
+ TcRnTypes: [uo_thing] :: CtOrigin -> Maybe SDoc
- TcRnTypes: ctEvId :: CtEvidence -> TcId
+ TcRnTypes: ctEvId :: Ct -> EvVar
- TcRnTypes: data ForeignSrcLang :: *
+ TcRnTypes: data ForeignSrcLang
- TcRnTypes: exprCtOrigin :: HsExpr Name -> CtOrigin
+ TcRnTypes: exprCtOrigin :: HsExpr GhcRn -> CtOrigin
- TcRnTypes: grhssCtOrigin :: GRHSs Name (LHsExpr Name) -> CtOrigin
+ TcRnTypes: grhssCtOrigin :: GRHSs GhcRn (LHsExpr GhcRn) -> CtOrigin
- TcRnTypes: lexprCtOrigin :: LHsExpr Name -> CtOrigin
+ TcRnTypes: lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin
- TcRnTypes: matchesCtOrigin :: MatchGroup Name (LHsExpr Name) -> CtOrigin
+ TcRnTypes: matchesCtOrigin :: MatchGroup GhcRn (LHsExpr GhcRn) -> CtOrigin
- TcRules: tcRules :: [LRuleDecls Name] -> TcM [LRuleDecls TcId]
+ TcRules: tcRules :: [LRuleDecls GhcRn] -> TcM [LRuleDecls GhcTcId]
- TcSMonad: IC :: InertEqs -> FunEqMap Ct -> DictMap Ct -> DictMap Ct -> Cts -> Cts -> Int -> InertCans
+ TcSMonad: IC :: InertEqs -> FunEqMap Ct -> DictMap Ct -> DictMap Ct -> Cts -> Int -> InertCans
- TcSMonad: IS :: InertCans -> ExactFunEqMap (TcCoercion, TcType, CtFlavour) -> DictMap CtEvidence -> InertSet
+ TcSMonad: IS :: InertCans -> [(TcTyVar, TcType)] -> ExactFunEqMap (TcCoercion, TcType, CtFlavour) -> DictMap CtEvidence -> InertSet
- TcSMonad: WL :: [Ct] -> [Ct] -> [Ct] -> [CtEvidence] -> Bag Implication -> WorkList
+ TcSMonad: WL :: [Ct] -> [Ct] -> [Ct] -> Bag Implication -> WorkList
- TcSMonad: findDict :: DictMap a -> Class -> [Type] -> Maybe a
+ TcSMonad: findDict :: DictMap a -> CtLoc -> Class -> [Type] -> Maybe a
- TcSMonad: getTcEvBindsMap :: TcS EvBindMap
+ TcSMonad: getTcEvBindsMap :: EvBindsVar -> TcS EvBindMap
- TcSMonad: getUnsolvedInerts :: TcS (Bag Implication, Cts, Cts, Cts, Cts)
+ TcSMonad: getUnsolvedInerts :: TcS (Bag Implication, Cts, Cts, Cts)
- TcSMonad: lookupInertDict :: InertCans -> Class -> [Type] -> Maybe CtEvidence
+ TcSMonad: lookupInertDict :: InertCans -> CtLoc -> Class -> [Type] -> Maybe CtEvidence
- TcSMonad: lookupSolvedDict :: InertSet -> Class -> [Type] -> Maybe CtEvidence
+ TcSMonad: lookupSolvedDict :: InertSet -> CtLoc -> Class -> [Type] -> Maybe CtEvidence
- TcSigs: PartialSig :: Name -> LHsSigWcType Name -> UserTypeCtxt -> SrcSpan -> TcIdSigInfo
+ TcSigs: PartialSig :: Name -> LHsSigWcType GhcRn -> UserTypeCtxt -> SrcSpan -> TcIdSigInfo
- TcSigs: [psig_hs_ty] :: TcIdSigInfo -> LHsSigWcType Name
+ TcSigs: [psig_hs_ty] :: TcIdSigInfo -> LHsSigWcType GhcRn
- TcSigs: addInlinePrags :: TcId -> [LSig Name] -> TcM TcId
+ TcSigs: addInlinePrags :: TcId -> [LSig GhcRn] -> TcM TcId
- TcSigs: extendPragEnv :: TcPragEnv -> (Name, LSig Name) -> TcPragEnv
+ TcSigs: extendPragEnv :: TcPragEnv -> (Name, LSig GhcRn) -> TcPragEnv
- TcSigs: lookupPragEnv :: TcPragEnv -> Name -> [LSig Name]
+ TcSigs: lookupPragEnv :: TcPragEnv -> Name -> [LSig GhcRn]
- TcSigs: mkPragEnv :: [LSig Name] -> LHsBinds Name -> TcPragEnv
+ TcSigs: mkPragEnv :: [LSig GhcRn] -> LHsBinds GhcRn -> TcPragEnv
- TcSigs: tcImpPrags :: [LSig Name] -> TcM [LTcSpecPrag]
+ TcSigs: tcImpPrags :: [LSig GhcRn] -> TcM [LTcSpecPrag]
- TcSigs: tcSpecPrags :: Id -> [LSig Name] -> TcM [LTcSpecPrag]
+ TcSigs: tcSpecPrags :: Id -> [LSig GhcRn] -> TcM [LTcSpecPrag]
- TcSigs: tcTySigs :: [LSig Name] -> TcM ([TcId], TcSigFun)
+ TcSigs: tcTySigs :: [LSig GhcRn] -> TcM ([TcId], TcSigFun)
- TcSigs: tcUserTypeSig :: SrcSpan -> LHsSigWcType Name -> Maybe Name -> TcM TcIdSigInfo
+ TcSigs: tcUserTypeSig :: SrcSpan -> LHsSigWcType GhcRn -> Maybe Name -> TcM TcIdSigInfo
- TcSigs: type TcPragEnv = NameEnv [LSig Name]
+ TcSigs: type TcPragEnv = NameEnv [LSig GhcRn]
- TcSimplify: growThetaTyVars :: ThetaType -> TyCoVarSet -> TyVarSet
+ TcSimplify: growThetaTyVars :: ThetaType -> TyCoVarSet -> TyCoVarSet
- TcSplice: runAnnotation :: CoreAnnTarget -> LHsExpr Name -> TcM Annotation
+ TcSplice: runAnnotation :: CoreAnnTarget -> LHsExpr GhcRn -> TcM Annotation
- TcSplice: runMeta' :: Bool -> (hs_syn -> SDoc) -> (SrcSpan -> ForeignHValue -> TcM (Either MsgDoc hs_syn)) -> LHsExpr Id -> TcM hs_syn
+ TcSplice: runMeta' :: Bool -> (hs_syn -> SDoc) -> (SrcSpan -> ForeignHValue -> TcM (Either MsgDoc hs_syn)) -> LHsExpr GhcTc -> TcM hs_syn
- TcSplice: runMetaD :: LHsExpr Id -> TcM [LHsDecl RdrName]
+ TcSplice: runMetaD :: LHsExpr GhcTc -> TcM [LHsDecl GhcPs]
- TcSplice: runMetaE :: LHsExpr Id -> TcM (LHsExpr RdrName)
+ TcSplice: runMetaE :: LHsExpr GhcTc -> TcM (LHsExpr GhcPs)
- TcSplice: runMetaP :: LHsExpr Id -> TcM (LPat RdrName)
+ TcSplice: runMetaP :: LHsExpr GhcTc -> TcM (LPat GhcPs)
- TcSplice: runMetaT :: LHsExpr Id -> TcM (LHsType RdrName)
+ TcSplice: runMetaT :: LHsExpr GhcTc -> TcM (LHsType GhcPs)
- TcSplice: tcSpliceExpr :: HsSplice Name -> ExpRhoType -> TcM (HsExpr TcId)
+ TcSplice: tcSpliceExpr :: HsSplice GhcRn -> ExpRhoType -> TcM (HsExpr GhcTcId)
- TcSplice: tcTopSpliceExpr :: SpliceType -> TcM (LHsExpr Id) -> TcM (LHsExpr Id)
+ TcSplice: tcTopSpliceExpr :: SpliceType -> TcM (LHsExpr GhcTc) -> TcM (LHsExpr GhcTc)
- TcSplice: tcTypedBracket :: HsBracket Name -> ExpRhoType -> TcM (HsExpr TcId)
+ TcSplice: tcTypedBracket :: HsExpr GhcRn -> HsBracket GhcRn -> ExpRhoType -> TcM (HsExpr GhcTcId)
- TcSplice: tcUntypedBracket :: HsBracket Name -> [PendingRnSplice] -> ExpRhoType -> TcM (HsExpr TcId)
+ TcSplice: tcUntypedBracket :: HsExpr GhcRn -> HsBracket GhcRn -> [PendingRnSplice] -> ExpRhoType -> TcM (HsExpr GhcTcId)
- TcTyClsDecls: dataDeclChecks :: Name -> NewOrData -> ThetaType -> [LConDecl Name] -> TcM Bool
+ TcTyClsDecls: dataDeclChecks :: Name -> NewOrData -> ThetaType -> [LConDecl GhcRn] -> TcM Bool
- TcTyClsDecls: kcDataDefn :: Name -> HsTyPats Name -> HsDataDefn Name -> TcKind -> TcM ()
+ TcTyClsDecls: kcDataDefn :: Maybe (VarEnv Kind) -> DataFamInstDecl GhcRn -> TcKind -> TcM ([TcType], TcKind)
- TcTyClsDecls: tcAddDataFamInstCtxt :: DataFamInstDecl Name -> TcM a -> TcM a
+ TcTyClsDecls: tcAddDataFamInstCtxt :: DataFamInstDecl GhcRn -> TcM a -> TcM a
- TcTyClsDecls: tcAddTyFamInstCtxt :: TyFamInstDecl Name -> TcM a -> TcM a
+ TcTyClsDecls: tcAddTyFamInstCtxt :: TyFamInstDecl GhcRn -> TcM a -> TcM a
- TcTyClsDecls: tcConDecls :: TyCon -> ([TyConBinder], Type) -> [LConDecl Name] -> TcM [DataCon]
+ TcTyClsDecls: tcConDecls :: TyCon -> ([TyConBinder], Type) -> [LConDecl GhcRn] -> TcM [DataCon]
- TcTyClsDecls: tcFamTyPats :: FamTyConShape -> Maybe ClsInstInfo -> HsTyPats Name -> (TcKind -> TcM ()) -> ([TcTyVar] -> [TcType] -> TcKind -> TcM a) -> TcM a
+ TcTyClsDecls: tcFamTyPats :: TcTyCon -> Maybe ClsInstInfo -> [Name] -> HsTyPats GhcRn -> (TcKind -> TcM ([TcType], TcKind)) -> ([TcTyVar] -> [TcType] -> TcKind -> TcM a) -> TcM a
- TcTyClsDecls: tcMkDataFamInstCtxt :: DataFamInstDecl Name -> SDoc
+ TcTyClsDecls: tcMkDataFamInstCtxt :: DataFamInstDecl GhcRn -> SDoc
- TcTyClsDecls: tcTyAndClassDecls :: [TyClGroup Name] -> TcM (TcGblEnv, [InstInfo Name], [DerivInfo])
+ TcTyClsDecls: tcTyAndClassDecls :: [TyClGroup GhcRn] -> TcM (TcGblEnv, [InstInfo GhcRn], [DerivInfo])
- TcTyClsDecls: tcTyFamInstEqn :: FamTyConShape -> Maybe ClsInstInfo -> LTyFamInstEqn Name -> TcM CoAxBranch
+ TcTyClsDecls: tcTyFamInstEqn :: TcTyCon -> Maybe ClsInstInfo -> LTyFamInstEqn GhcRn -> TcM CoAxBranch
- TcTyDecls: checkSynCycles :: UnitId -> [TyCon] -> [LTyClDecl Name] -> TcM ()
+ TcTyDecls: checkSynCycles :: UnitId -> [TyCon] -> [LTyClDecl GhcRn] -> TcM ()
- TcTyDecls: mkOneRecordSelector :: [ConLike] -> RecSelParent -> FieldLabel -> (LSig Name, (RecFlag, LHsBinds Name))
+ TcTyDecls: mkOneRecordSelector :: [ConLike] -> RecSelParent -> FieldLabel -> (LSig GhcRn, (RecFlag, LHsBinds GhcRn))
- TcTyDecls: mkRecSelBinds :: [TyCon] -> HsValBinds Name
+ TcTyDecls: mkRecSelBinds :: [TyCon] -> HsValBinds GhcRn
- TcType: anyRewritableTyVar :: Bool -> (TcTyVar -> Bool) -> TcType -> Bool
+ TcType: anyRewritableTyVar :: Bool -> EqRel -> (EqRel -> TcTyVar -> Bool) -> TcType -> Bool
- TcType: fmvTcLevel :: TcLevel -> TcLevel
+ TcType: fmvTcLevel :: TcLevel
- TcType: isCallStackPred :: PredType -> Maybe FastString
+ TcType: isCallStackPred :: Class -> [Type] -> Maybe FastString
- TcType: mkMinimalBySCs :: [PredType] -> [PredType]
+ TcType: mkMinimalBySCs :: forall a. (a -> PredType) -> [a] -> [a]
- TcType: toposortTyVars :: [TyVar] -> [TyVar]
+ TcType: toposortTyVars :: [TyCoVar] -> [TyCoVar]
- TcType: typeKind :: Type -> Kind
+ TcType: typeKind :: HasDebugCallStack => Type -> Kind
- TcTypeNats: BuiltInSynFamily :: ([Type] -> Maybe (CoAxiomRule, [Type], Type)) -> ([Type] -> Type -> [TypeEqn]) -> ([Type] -> Type -> [Type] -> Type -> [TypeEqn]) -> BuiltInSynFamily
+ TcTypeNats: BuiltInSynFamily :: [Type] -> Maybe (CoAxiomRule, [Type], Type) -> [Type] -> Type -> [TypeEqn] -> [Type] -> Type -> [Type] -> Type -> [TypeEqn] -> BuiltInSynFamily
- TcUnify: matchActualFunTys :: Outputable a => SDoc -> CtOrigin -> Maybe a -> Arity -> TcSigmaType -> TcM (HsWrapper, [TcSigmaType], TcSigmaType)
+ TcUnify: matchActualFunTys :: SDoc -> CtOrigin -> Maybe (HsExpr GhcRn) -> Arity -> TcSigmaType -> TcM (HsWrapper, [TcSigmaType], TcSigmaType)
- TcUnify: matchActualFunTysPart :: Outputable a => SDoc -> CtOrigin -> Maybe a -> Arity -> TcSigmaType -> [TcSigmaType] -> Arity -> TcM (HsWrapper, [TcSigmaType], TcSigmaType)
+ TcUnify: matchActualFunTysPart :: SDoc -> CtOrigin -> Maybe (HsExpr GhcRn) -> Arity -> TcSigmaType -> [TcSigmaType] -> Arity -> TcM (HsWrapper, [TcSigmaType], TcSigmaType)
- TcUnify: matchExpectedFunKind :: Arity -> TcType -> TcKind -> TcM (Coercion, TcKind, TcKind)
+ TcUnify: matchExpectedFunKind :: Outputable fun => fun -> TcKind -> TcM (Coercion, TcKind, TcKind)
- TcUnify: tcSubTypeDS_NC_O :: Outputable a => CtOrigin -> UserTypeCtxt -> Maybe a -> TcSigmaType -> ExpRhoType -> TcM HsWrapper
+ TcUnify: tcSubTypeDS_NC_O :: CtOrigin -> UserTypeCtxt -> Maybe (HsExpr GhcRn) -> TcSigmaType -> ExpRhoType -> TcM HsWrapper
- TcUnify: tcSubTypeHR :: Outputable a => CtOrigin -> Maybe a -> TcSigmaType -> ExpRhoType -> TcM HsWrapper
+ TcUnify: tcSubTypeHR :: CtOrigin -> Maybe (HsExpr GhcRn) -> TcSigmaType -> ExpRhoType -> TcM HsWrapper
- TcUnify: tcWrapResult :: HsExpr Name -> HsExpr TcId -> TcSigmaType -> ExpRhoType -> TcM (HsExpr TcId)
+ TcUnify: tcWrapResult :: HsExpr GhcRn -> HsExpr GhcTcId -> TcSigmaType -> ExpRhoType -> TcM (HsExpr GhcTcId)
- TcUnify: tcWrapResultO :: CtOrigin -> HsExpr TcId -> TcSigmaType -> ExpRhoType -> TcM (HsExpr TcId)
+ TcUnify: tcWrapResultO :: CtOrigin -> HsExpr GhcRn -> HsExpr GhcTcId -> TcSigmaType -> ExpRhoType -> TcM (HsExpr GhcTcId)
- TcUnify: uType :: CtOrigin -> TypeOrKind -> TcType -> TcType -> TcM Coercion
+ TcUnify: uType :: TypeOrKind -> CtOrigin -> TcType -> TcType -> TcM Coercion
- TcUnify: unifyKind :: Outputable a => Maybe a -> TcKind -> TcKind -> TcM CoercionN
+ TcUnify: unifyKind :: Maybe (HsType GhcRn) -> TcKind -> TcKind -> TcM CoercionN
- TcUnify: unifyType :: Outputable a => Maybe a -> TcTauType -> TcTauType -> TcM TcCoercionN
+ TcUnify: unifyType :: Maybe (HsExpr GhcRn) -> TcTauType -> TcTauType -> TcM TcCoercionN
- TcValidity: arityErr :: Outputable a => String -> a -> Int -> Int -> SDoc
+ TcValidity: arityErr :: Outputable a => SDoc -> a -> Int -> Int -> SDoc
- TcValidity: checkValidFamPats :: Maybe ClsInstInfo -> TyCon -> [TyVar] -> [CoVar] -> [Type] -> TcM ()
+ TcValidity: checkValidFamPats :: Maybe ClsInstInfo -> TyCon -> [TyVar] -> [CoVar] -> [Type] -> [Type] -> SDoc -> TcM ()
- TcValidity: checkValidInstance :: UserTypeCtxt -> LHsSigType Name -> Type -> TcM ([TyVar], ThetaType, Class, [Type])
+ TcValidity: checkValidInstance :: UserTypeCtxt -> LHsSigType GhcRn -> Type -> TcM ([TyVar], ThetaType, Class, [Type])
- TcValidity: checkValidTyFamEqn :: Maybe ClsInstInfo -> TyCon -> [TyVar] -> [CoVar] -> [Type] -> Type -> SrcSpan -> TcM ()
+ TcValidity: checkValidTyFamEqn :: Maybe ClsInstInfo -> TyCon -> [TyVar] -> [CoVar] -> [Type] -> Type -> SDoc -> SrcSpan -> TcM ()
- TmOracle: PmExprOther :: (HsExpr Id) -> PmExpr
+ TmOracle: PmExprOther :: (HsExpr GhcTc) -> PmExpr
- TmOracle: PmOLit :: Bool -> (HsOverLit Id) -> PmLit
+ TmOracle: PmOLit :: Bool -> (HsOverLit GhcTc) -> PmLit
- TmOracle: PmSLit :: HsLit -> PmLit
+ TmOracle: PmSLit :: (HsLit GhcTc) -> PmLit
- TmOracle: hsExprToPmExpr :: HsExpr Id -> PmExpr
+ TmOracle: hsExprToPmExpr :: HsExpr GhcTc -> PmExpr
- TmOracle: lhsExprToPmExpr :: LHsExpr Id -> PmExpr
+ TmOracle: lhsExprToPmExpr :: LHsExpr GhcTc -> PmExpr
- TyCon: mkTcTyCon :: Name -> [TyConBinder] -> Kind -> Bool -> [TyVar] -> TyCon
+ TyCon: mkTcTyCon :: Name -> [TyConBinder] -> Kind -> [(Name, TyVar)] -> TyConFlavour -> TyCon
- TyCon: tcTyConScopedTyVars :: TyCon -> [TyVar]
+ TyCon: tcTyConScopedTyVars :: TyCon -> [(Name, TyVar)]
- TyCon: tyConFlavour :: TyCon -> String
+ TyCon: tyConFlavour :: TyCon -> TyConFlavour
- Type: TyCoMapper :: Bool -> (env -> TyVar -> m Type) -> (env -> CoVar -> m Coercion) -> (env -> CoercionHole -> Role -> Type -> Type -> m Coercion) -> (env -> TyVar -> ArgFlag -> m (env, TyVar)) -> TyCoMapper env m
+ Type: TyCoMapper :: Bool -> env -> TyVar -> m Type -> env -> CoVar -> m Coercion -> env -> CoercionHole -> m Coercion -> env -> TyVar -> ArgFlag -> m (env, TyVar) -> TyCoMapper env m
- Type: [tcm_hole] :: TyCoMapper env m -> env -> CoercionHole -> Role -> Type -> Type -> m Coercion
+ Type: [tcm_hole] :: TyCoMapper env m -> env -> CoercionHole -> m Coercion
- Type: getCastedTyVar_maybe :: Type -> Maybe (TyVar, Coercion)
+ Type: getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)
- Type: piResultTy :: Type -> Type -> Type
+ Type: piResultTy :: HasDebugCallStack => Type -> Type -> Type
- Type: piResultTys :: Type -> [Type] -> Type
+ Type: piResultTys :: HasDebugCallStack => Type -> [Type] -> Type
- Type: repSplitAppTy_maybe :: Type -> Maybe (Type, Type)
+ Type: repSplitAppTy_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)
- Type: repSplitAppTys :: Type -> (Type, [Type])
+ Type: repSplitAppTys :: HasDebugCallStack => Type -> (Type, [Type])
- Type: toposortTyVars :: [TyVar] -> [TyVar]
+ Type: toposortTyVars :: [TyCoVar] -> [TyCoVar]
- Type: typeKind :: Type -> Kind
+ Type: typeKind :: HasDebugCallStack => Type -> Kind
- UniqDFM: udfmIntersectUFM :: UniqDFM elt -> UniqFM elt -> UniqDFM elt
+ UniqDFM: udfmIntersectUFM :: UniqDFM elt1 -> UniqFM elt2 -> UniqDFM elt1
- UniqDSet: uniqDSetMinusUniqSet :: UniqDSet a -> UniqSet a -> UniqDSet a
+ UniqDSet: uniqDSetMinusUniqSet :: UniqDSet a -> UniqSet b -> UniqDSet a
- Util: foldl1' :: () => (a -> a -> a) -> [a] -> a
+ Util: foldl1' :: () => a -> a -> a -> [a] -> a
- Util: sortWith :: Ord b => (a -> b) -> [a] -> [a]
+ Util: sortWith :: Ord b => a -> b -> [a] -> [a]
- Util: type HasCallStack = HasCallStack
+ Util: type HasCallStack = ?callStack :: CallStack
- Vectorise.Monad.Base: VM :: (Builtins -> GlobalEnv -> LocalEnv -> DsM (VResult a)) -> VM a
+ Vectorise.Monad.Base: VM :: Builtins -> GlobalEnv -> LocalEnv -> DsM (VResult a) -> VM a
This diff is very large; some files are shown as “too large to diff”. Download the raw patch for the complete diff.
Files
- HsVersions.h +1/−5
- autogen/CodeGen.Platform.hs +234/−230
- autogen/Config.hs +8/−6
- autogen/ghc_boot_platform.h +1/−0
- autogen/primop-can-fail.hs-incl +1/−2
- autogen/primop-data-decl.hs-incl +11/−0
- autogen/primop-list.hs-incl +11/−0
- autogen/primop-primop-info.hs-incl +11/−0
- autogen/primop-tag.hs-incl +1082/−1071
- backpack/BkpSyn.hs +3/−2
- backpack/DriverBkp.hs +9/−5
- backpack/NameShape.hs +3/−1
- backpack/RnModIface.hs +9/−1
- basicTypes/Avail.hs +5/−1
- basicTypes/BasicTypes.hs +128/−24
- basicTypes/ConLike.hs +2/−0
- basicTypes/DataCon.hs +207/−63
- basicTypes/DataCon.hs-boot +4/−3
- basicTypes/Demand.hs +32/−27
- basicTypes/FieldLabel.hs +2/−0
- basicTypes/Id.hs +17/−6
- basicTypes/IdInfo.hs +2/−0
- basicTypes/IdInfo.hs-boot +1/−0
- basicTypes/Lexeme.hs +2/−0
- basicTypes/Literal.hs +24/−1
- basicTypes/MkId.hs +72/−11
- basicTypes/Module.hs +36/−10
- basicTypes/Module.hs-boot +2/−0
- basicTypes/Name.hs +14/−13
- basicTypes/Name.hs-boot +2/−0
- basicTypes/NameCache.hs +2/−0
- basicTypes/NameEnv.hs +5/−2
- basicTypes/NameSet.hs +2/−0
- basicTypes/OccName.hs +9/−16
- basicTypes/OccName.hs-boot +2/−0
- basicTypes/PatSyn.hs +50/−10
- basicTypes/RdrName.hs +47/−12
- basicTypes/SrcLoc.hs +3/−5
- basicTypes/UniqSupply.hs +2/−0
- basicTypes/Unique.hs +6/−0
- basicTypes/Var.hs +14/−3
- basicTypes/VarEnv.hs +6/−1
- basicTypes/VarSet.hs +10/−4
- cmm/Bitmap.hs +2/−0
- cmm/BlockId.hs +8/−12
- cmm/BlockId.hs-boot +8/−0
- cmm/CLabel.hs +203/−163
- cmm/Cmm.hs +19/−10
- cmm/CmmBuildInfoTables.hs +11/−7
- cmm/CmmCallConv.hs +5/−2
- cmm/CmmCommonBlockElim.hs +14/−5
- cmm/CmmContFlowOpt.hs +12/−6
- cmm/CmmExpr.hs +2/−0
- cmm/CmmImplementSwitchPlans.hs +4/−2
- cmm/CmmInfo.hs +15/−3
- cmm/CmmLayoutStack.hs +133/−34
- cmm/CmmLex.x +2/−0
- cmm/CmmLint.hs +6/−1
- cmm/CmmLive.hs +6/−1
- cmm/CmmMachOp.hs +15/−1
- cmm/CmmMonad.hs +4/−7
- cmm/CmmNode.hs +5/−2
- cmm/CmmOpt.hs +100/−53
- cmm/CmmParse.y +17/−2
- cmm/CmmPipeline.hs +3/−1
- cmm/CmmProcPoint.hs +12/−7
- cmm/CmmSink.hs +64/−14
- cmm/CmmSwitch.hs +4/−2
- cmm/CmmType.hs +2/−0
- cmm/CmmUtils.hs +8/−7
- cmm/Debug.hs +6/−1
- cmm/Hoopl.hs +0/−29
- cmm/Hoopl/Block.hs +328/−0
- cmm/Hoopl/Collections.hs +89/−0
- cmm/Hoopl/Dataflow.hs +160/−29
- cmm/Hoopl/Graph.hs +201/−0
- cmm/Hoopl/Label.hs +124/−0
- cmm/Hoopl/Unique.hs +93/−0
- cmm/MkGraph.hs +6/−3
- cmm/PprC.hs +54/−31
- cmm/PprCmm.hs +4/−3
- cmm/PprCmmDecl.hs +2/−0
- cmm/PprCmmExpr.hs +2/−0
- cmm/SMRep.hs +10/−5
- codeGen/CgUtils.hs +4/−1
- codeGen/CodeGen/Platform.hs +2/−0
- codeGen/CodeGen/Platform/ARM.hs +2/−0
- codeGen/CodeGen/Platform/ARM64.hs +2/−0
- codeGen/CodeGen/Platform/NoRegs.hs +2/−0
- codeGen/CodeGen/Platform/PPC.hs +2/−0
- codeGen/CodeGen/Platform/PPC_Darwin.hs +2/−0
- codeGen/CodeGen/Platform/SPARC.hs +2/−0
- codeGen/CodeGen/Platform/X86.hs +2/−0
- codeGen/CodeGen/Platform/X86_64.hs +2/−0
- codeGen/StgCmm.hs +4/−39
- codeGen/StgCmmArgRep.hs +2/−0
- codeGen/StgCmmBind.hs +3/−3
- codeGen/StgCmmClosure.hs +14/−11
- codeGen/StgCmmCon.hs +12/−5
- codeGen/StgCmmEnv.hs +2/−0
- codeGen/StgCmmExpr.hs +32/−13
- codeGen/StgCmmExtCode.hs +2/−0
- codeGen/StgCmmForeign.hs +2/−2
- codeGen/StgCmmHeap.hs +4/−17
- codeGen/StgCmmHpc.hs +2/−0
- codeGen/StgCmmLayout.hs +79/−18
- codeGen/StgCmmMonad.hs +28/−58
- codeGen/StgCmmPrim.hs +115/−5
- codeGen/StgCmmProf.hs +3/−1
- codeGen/StgCmmTicky.hs +5/−2
- codeGen/StgCmmUtils.hs +4/−2
- coreSyn/CoreArity.hs +82/−130
- coreSyn/CoreFVs.hs +28/−81
- coreSyn/CoreLint.hs +142/−78
- coreSyn/CoreOpt.hs +9/−47
- coreSyn/CorePrep.hs +70/−7
- coreSyn/CoreSeq.hs +2/−0
- coreSyn/CoreStats.hs +24/−26
- coreSyn/CoreSubst.hs +3/−1
- coreSyn/CoreSyn.hs +39/−11
- coreSyn/CoreTidy.hs +9/−11
- coreSyn/CoreUnfold.hs +12/−10
- coreSyn/CoreUtils.hs +170/−101
- coreSyn/MkCore.hs +29/−19
- coreSyn/PprCore.hs +5/−3
- coreSyn/TrieMap.hs +8/−2
- deSugar/Check.hs +289/−107
- deSugar/Coverage.hs +90/−103
- deSugar/Desugar.hs +24/−10
- deSugar/DsArrows.hs +45/−42
- deSugar/DsBinds.hs +137/−155
- deSugar/DsCCall.hs +5/−3
- deSugar/DsExpr.hs +208/−106
- deSugar/DsExpr.hs-boot +8/−8
- deSugar/DsForeign.hs +8/−4
- deSugar/DsGRHSs.hs +14/−12
- deSugar/DsListComp.hs +32/−29
- deSugar/DsMeta.hs +210/−246
- deSugar/DsMonad.hs +37/−4
- deSugar/DsUsage.hs +2/−0
- deSugar/DsUtils.hs +17/−14
- deSugar/Match.hs +78/−103
- deSugar/Match.hs-boot +7/−4
- deSugar/MatchCon.hs +12/−8
- deSugar/MatchLit.hs +54/−50
- deSugar/PmExpr.hs +8/−6
- deSugar/TmOracle.hs +2/−0
- dist/build/CmmLex.hs +3/−1
- dist/build/CmmParse.hs +17/−2
- dist/build/Lexer.hs +438/−327
- dist/build/Parser.hs +12003/−11934
- ghc.cabal +51/−28
- ghci/ByteCodeAsm.hs +18/−1
- ghci/ByteCodeGen.hs +369/−213
- ghci/ByteCodeInstr.hs +63/−10
- ghci/ByteCodeItbls.hs +2/−0
- ghci/ByteCodeLink.hs +6/−14
- ghci/ByteCodeTypes.hs +4/−6
- ghci/Debugger.hs +2/−0
- ghci/DebuggerUtils.hs +4/−2
- ghci/GHCi.hs +653/−0
- ghci/GHCi.hsc +0/−677
- ghci/Linker.hs +116/−34
- ghci/RtClosureInspect.hs +80/−44
- hsSyn/Convert.hs +158/−110
- hsSyn/HsBinds.hs +194/−186
- hsSyn/HsDecls.hs +371/−308
- hsSyn/HsDoc.hs +2/−0
- hsSyn/HsDumpAst.hs +87/−73
- hsSyn/HsExpr.hs +315/−253
- hsSyn/HsExpr.hs-boot +21/−19
- hsSyn/HsExtension.hs +291/−0
- hsSyn/HsImpExp.hs +24/−17
- hsSyn/HsLit.hs +126/−60
- hsSyn/HsPat.hs +152/−98
- hsSyn/HsPat.hs-boot +3/−3
- hsSyn/HsSyn.hs +6/−3
- hsSyn/HsTypes.hs +291/−253
- hsSyn/HsUtils.hs +282/−217
- hsSyn/PlaceHolder.hs +2/−50
- iface/BinFingerprint.hs +2/−0
- iface/BinIface.hs +26/−11
- iface/BuildTyCl.hs +20/−77
- iface/FlagChecker.hs +58/−11
- iface/IfaceEnv.hs +3/−1
- iface/IfaceSyn.hs +139/−96
- iface/IfaceType.hs +167/−221
- iface/IfaceType.hs-boot +6/−25
- iface/LoadIface.hs +7/−2
- iface/MkIface.hs +71/−14
- iface/TcIface.hs +98/−45
- iface/TcIface.hs-boot +1/−0
- iface/ToIface.hs +16/−15
- iface/ToIface.hs-boot +4/−5
- llvmGen/Llvm/AbsSyn.hs +7/−5
- llvmGen/Llvm/MetaData.hs +2/−0
- llvmGen/Llvm/PpLlvm.hs +3/−1
- llvmGen/Llvm/Types.hs +3/−1
- llvmGen/LlvmCodeGen.hs +14/−2
- llvmGen/LlvmCodeGen/Base.hs +2/−0
- llvmGen/LlvmCodeGen/CodeGen.hs +91/−30
- llvmGen/LlvmCodeGen/Data.hs +17/−17
- llvmGen/LlvmCodeGen/Ppr.hs +3/−63
- llvmGen/LlvmCodeGen/Regs.hs +2/−0
- llvmGen/LlvmMangler.hs +2/−0
- main/Annotations.hs +2/−0
- main/Ar.hs +260/−0
- main/CmdLineParser.hs +40/−8
- main/CodeOutput.hs +5/−3
- main/Constants.hs +6/−0
- main/DriverMkDepend.hs +13/−9
- main/DriverPhases.hs +2/−0
- main/DriverPipeline.hs +272/−365
- main/DynFlags.hs +339/−162
- main/DynFlags.hs-boot +1/−1
- main/DynamicLoading.hs +5/−3
- main/Elf.hs +6/−10
- main/ErrUtils.hs +101/−55
- main/ErrUtils.hs-boot +1/−0
- main/FileCleanup.hs +299/−0
- main/Finder.hs +2/−0
- main/GHC.hs +46/−42
- main/GhcMake.hs +312/−111
- main/GhcMonad.hs +2/−0
- main/HeaderInfo.hs +8/−5
- main/Hooks.hs +20/−12
- main/Hooks.hs-boot +2/−0
- main/HscMain.hs +146/−124
- main/HscStats.hs +3/−2
- main/HscTypes.hs +141/−41
- main/InteractiveEval.hs +21/−17
- main/InteractiveEvalTypes.hs +2/−6
- main/PackageConfig.hs +2/−0
- main/Packages.hs +58/−34
- main/Packages.hs-boot +1/−0
- main/PipelineMonad.hs +4/−1
- main/PlatformConstants.hs +2/−0
- main/Plugins.hs +3/−1
- main/PprTyThing.hs +2/−0
- main/StaticPtrTable.hs +5/−3
- main/SysTools.hs +517/−1716
- main/SysTools/BaseDir.hs +199/−0
- main/SysTools/ExtraObj.hs +239/−0
- main/SysTools/Info.hs +260/−0
- main/SysTools/Process.hs +347/−0
- main/SysTools/Tasks.hs +343/−0
- main/SysTools/Terminal.hs +3/−0
- main/TidyPgm.hs +3/−1
- nativeGen/AsmCodeGen.hs +16/−13
- nativeGen/CPrim.hs +22/−0
- nativeGen/Dwarf.hs +4/−1
- nativeGen/Dwarf/Constants.hs +8/−4
- nativeGen/Dwarf/Types.hs +5/−2
- nativeGen/Format.hs +3/−0
- nativeGen/Instruction.hs +4/−1
- nativeGen/NCG.h +1/−4
- nativeGen/NCGMonad.hs +6/−6
- nativeGen/PIC.hs +3/−1
- nativeGen/PPC/CodeGen.hs +139/−39
- nativeGen/PPC/Cond.hs +2/−0
- nativeGen/PPC/Instr.hs +37/−23
- nativeGen/PPC/Ppr.hs +67/−25
- nativeGen/PPC/RegInfo.hs +5/−3
- nativeGen/PPC/Regs.hs +3/−1
- nativeGen/PprBase.hs +24/−12
- nativeGen/Reg.hs +2/−0
- nativeGen/RegAlloc/Graph/ArchBase.hs +3/−1
- nativeGen/RegAlloc/Graph/ArchX86.hs +21/−6
- nativeGen/RegAlloc/Graph/Coalesce.hs +3/−1
- nativeGen/RegAlloc/Graph/Main.hs +2/−0
- nativeGen/RegAlloc/Graph/Spill.hs +4/−2
- nativeGen/RegAlloc/Graph/SpillClean.hs +3/−1
- nativeGen/RegAlloc/Graph/SpillCost.hs +4/−2
- nativeGen/RegAlloc/Graph/Stats.hs +2/−0
- nativeGen/RegAlloc/Graph/TrivColorable.hs +2/−0
- nativeGen/RegAlloc/Linear/Base.hs +2/−0
- nativeGen/RegAlloc/Linear/FreeRegs.hs +2/−0
- nativeGen/RegAlloc/Linear/JoinToTargets.hs +13/−11
- nativeGen/RegAlloc/Linear/Main.hs +17/−13
- nativeGen/RegAlloc/Linear/PPC/FreeRegs.hs +2/−0
- nativeGen/RegAlloc/Linear/SPARC/FreeRegs.hs +2/−0
- nativeGen/RegAlloc/Linear/StackMap.hs +2/−0
- nativeGen/RegAlloc/Linear/State.hs +2/−0
- nativeGen/RegAlloc/Linear/Stats.hs +2/−0
- nativeGen/RegAlloc/Linear/X86/FreeRegs.hs +2/−0
- nativeGen/RegAlloc/Linear/X86_64/FreeRegs.hs +2/−0
- nativeGen/RegAlloc/Liveness.hs +15/−12
- nativeGen/RegClass.hs +2/−0
- nativeGen/SPARC/AddrMode.hs +2/−0
- nativeGen/SPARC/Base.hs +2/−0
- nativeGen/SPARC/CodeGen.hs +9/−4
- nativeGen/SPARC/CodeGen/Amode.hs +2/−0
- nativeGen/SPARC/CodeGen/Base.hs +2/−0
- nativeGen/SPARC/CodeGen/CondCode.hs +2/−0
- nativeGen/SPARC/CodeGen/Expand.hs +2/−0
- nativeGen/SPARC/CodeGen/Gen32.hs +2/−0
- nativeGen/SPARC/CodeGen/Gen64.hs +2/−0
- nativeGen/SPARC/CodeGen/Sanity.hs +2/−0
- nativeGen/SPARC/Cond.hs +2/−0
- nativeGen/SPARC/Imm.hs +2/−0
- nativeGen/SPARC/Instr.hs +2/−0
- nativeGen/SPARC/Ppr.hs +10/−6
- nativeGen/SPARC/Regs.hs +3/−1
- nativeGen/SPARC/ShortcutJump.hs +5/−5
- nativeGen/SPARC/Stack.hs +2/−0
- nativeGen/TargetReg.hs +2/−0
- nativeGen/X86/CodeGen.hs +106/−13
- nativeGen/X86/Cond.hs +2/−0
- nativeGen/X86/Instr.hs +20/−6
- nativeGen/X86/Ppr.hs +23/−5
- nativeGen/X86/RegInfo.hs +2/−0
- nativeGen/X86/Regs.hs +13/−7
- parser/ApiAnnotation.hs +2/−0
- parser/Ctype.hs +2/−0
- parser/HaddockUtils.hs +2/−0
- parser/Lexer.x +167/−69
- parser/Parser.y +259/−236
- parser/RdrHsSyn.hs +173/−157
- parser/cutils.c +1/−1
- prelude/ForeignCall.hs +3/−1
- prelude/KnownUniques.hs +2/−0
- prelude/KnownUniques.hs-boot +1/−0
- prelude/PrelInfo.hs +21/−2
- prelude/PrelNames.hs +62/−39
- prelude/PrelRules.hs +197/−101
- prelude/PrimOp.hs +8/−3
- prelude/PrimOp.hs-boot +2/−0
- prelude/THNames.hs +64/−70
- prelude/TysPrim.hs +22/−18
- prelude/TysWiredIn.hs +22/−28
- profiling/CostCentre.hs +14/−16
- profiling/ProfInit.hs +34/−16
- profiling/SCCfinal.hs +0/−285
- rename/RnBinds.hs +207/−134
- rename/RnEnv.hs +1585/−2347
- rename/RnExpr.hs +173/−130
- rename/RnExpr.hs-boot +11/−11
- rename/RnFixity.hs +211/−0
- rename/RnHsDoc.hs +2/−0
- rename/RnNames.hs +64/−43
- rename/RnPat.hs +122/−67
- rename/RnSource.hs +220/−366
- rename/RnSplice.hs +37/−30
- rename/RnSplice.hs-boot +6/−7
- rename/RnTypes.hs +491/−341
- rename/RnUnbound.hs +342/−0
- rename/RnUtils.hs +413/−0
- simplCore/CSE.hs +33/−9
- simplCore/CallArity.hs +35/−11
- simplCore/CoreMonad.hs +12/−10
- simplCore/Exitify.hs +442/−0
- simplCore/FloatIn.hs +238/−135
- simplCore/FloatOut.hs +19/−10
- simplCore/LiberateCase.hs +2/−0
- simplCore/OccurAnal.hs +122/−45
- simplCore/SAT.hs +2/−0
- simplCore/SetLevels.hs +101/−34
- simplCore/SimplCore.hs +19/−8
- simplCore/SimplEnv.hs +249/−185
- simplCore/SimplMonad.hs +44/−11
- simplCore/SimplUtils.hs +371/−163
- simplCore/Simplify.hs +3327/−3388
- simplStg/RepType.hs +3/−5
- simplStg/SimplStg.hs +18/−38
- simplStg/StgCse.hs +41/−10
- simplStg/StgStats.hs +2/−0
- simplStg/UnariseStg.hs +3/−1
- specialise/Rules.hs +11/−10
- specialise/SpecConstr.hs +63/−13
- specialise/Specialise.hs +8/−10
- stgSyn/CoreToStg.hs +164/−65
- stgSyn/StgLint.hs +55/−72
- stgSyn/StgSyn.hs +12/−7
- stranal/DmdAnal.hs +73/−26
- stranal/WorkWrap.hs +9/−3
- stranal/WwLib.hs +7/−2
- typecheck/FamInst.hs +125/−129
- typecheck/FunDeps.hs +6/−4
- typecheck/Inst.hs +46/−43
- typecheck/TcAnnotations.hs +11/−8
- typecheck/TcArrows.hs +16/−12
- typecheck/TcBackpack.hs +117/−20
- typecheck/TcBinds.hs +182/−124
- typecheck/TcCanonical.hs +284/−186
- typecheck/TcClassDcl.hs +51/−30
- typecheck/TcDefaults.hs +6/−4
- typecheck/TcDeriv.hs +551/−419
- typecheck/TcDerivInfer.hs +242/−188
- typecheck/TcDerivUtils.hs +162/−28
- typecheck/TcEnv.hs +94/−50
- typecheck/TcEnv.hs-boot +10/−6
- typecheck/TcErrors.hs +427/−127
- typecheck/TcEvidence.hs +17/−6
- typecheck/TcExpr.hs +267/−154
- typecheck/TcExpr.hs-boot +16/−15
- typecheck/TcFlatten.hs +74/−56
- typecheck/TcForeign.hs +16/−9
- typecheck/TcGenDeriv.hs +203/−156
- typecheck/TcGenFunctor.hs +349/−86
- typecheck/TcGenGenerics.hs +27/−28
- typecheck/TcHsSyn.hs too large to diff
- typecheck/TcHsType.hs too large to diff
- typecheck/TcInstDcls.hs too large to diff
- typecheck/TcInstDcls.hs-boot too large to diff
- typecheck/TcInteract.hs too large to diff
- typecheck/TcMType.hs too large to diff
- typecheck/TcMatches.hs too large to diff
- typecheck/TcMatches.hs-boot too large to diff
- typecheck/TcPat.hs too large to diff
- typecheck/TcPatSyn.hs too large to diff
- typecheck/TcPatSyn.hs-boot too large to diff
- typecheck/TcPluginM.hs too large to diff
- typecheck/TcRnDriver.hs too large to diff
- typecheck/TcRnDriver.hs-boot too large to diff
- typecheck/TcRnExports.hs too large to diff
- typecheck/TcRnMonad.hs too large to diff
- typecheck/TcRnTypes.hs too large to diff
- typecheck/TcRules.hs too large to diff
- typecheck/TcSMonad.hs too large to diff
- typecheck/TcSigs.hs too large to diff
- typecheck/TcSimplify.hs too large to diff
- typecheck/TcSimplify.hs-boot too large to diff
- typecheck/TcSplice.hs too large to diff
- typecheck/TcSplice.hs-boot too large to diff
- typecheck/TcTyClsDecls.hs too large to diff
- typecheck/TcTyDecls.hs too large to diff
- typecheck/TcType.hs too large to diff
- typecheck/TcTypeNats.hs too large to diff
- typecheck/TcTypeable.hs too large to diff
- typecheck/TcUnify.hs too large to diff
- typecheck/TcUnify.hs-boot too large to diff
- typecheck/TcValidity.hs too large to diff
- types/Class.hs too large to diff
- types/CoAxiom.hs too large to diff
- types/Coercion.hs too large to diff
- types/Coercion.hs-boot too large to diff
- types/FamInstEnv.hs too large to diff
- types/InstEnv.hs too large to diff
- types/Kind.hs too large to diff
- types/OptCoercion.hs too large to diff
- types/TyCoRep.hs too large to diff
- types/TyCon.hs too large to diff
- types/TyCon.hs-boot too large to diff
- types/Type.hs too large to diff
- types/Type.hs-boot too large to diff
- types/Unify.hs too large to diff
- utils/AsmUtils.hs too large to diff
- utils/Bag.hs too large to diff
- utils/Binary.hs too large to diff
- utils/BooleanFormula.hs too large to diff
- utils/BufWrite.hs too large to diff
- utils/Digraph.hs too large to diff
- utils/Encoding.hs too large to diff
- utils/EnumSet.hs too large to diff
- utils/Exception.hs too large to diff
- utils/FV.hs too large to diff
- utils/FastFunctions.hs too large to diff
- utils/FastMutInt.hs too large to diff
- utils/FastString.hs too large to diff
- utils/FastStringEnv.hs too large to diff
- utils/Fingerprint.hsc too large to diff
- utils/FiniteMap.hs too large to diff
- utils/GhcPrelude.hs too large to diff
- utils/GraphBase.hs too large to diff
- utils/GraphColor.hs too large to diff
- utils/GraphOps.hs too large to diff
- utils/GraphPpr.hs too large to diff
- utils/IOEnv.hs too large to diff
- utils/Json.hs too large to diff
- utils/ListSetOps.hs too large to diff
- utils/ListT.hs too large to diff
- utils/Maybes.hs too large to diff
- utils/MonadUtils.hs too large to diff
- utils/OrdList.hs too large to diff
- utils/Outputable.hs too large to diff
- utils/Outputable.hs-boot too large to diff
- utils/Pair.hs too large to diff
- utils/Panic.hs too large to diff
- utils/Platform.hs too large to diff
- utils/PprColour.hs too large to diff
- utils/Pretty.hs too large to diff
- utils/State.hs too large to diff
- utils/Stream.hs too large to diff
- utils/StringBuffer.hs too large to diff
- utils/UnVarGraph.hs too large to diff
- utils/UniqDFM.hs too large to diff
- utils/UniqDSet.hs too large to diff
- utils/UniqFM.hs too large to diff
- utils/UniqMap.hs too large to diff
- utils/UniqSet.hs too large to diff
- utils/Util.hs too large to diff
- utils/md5.h too large to diff
- vectorise/Vectorise.hs too large to diff
- vectorise/Vectorise/Builtins/Base.hs too large to diff
- vectorise/Vectorise/Builtins/Initialise.hs too large to diff
- vectorise/Vectorise/Convert.hs too large to diff
- vectorise/Vectorise/Env.hs too large to diff
- vectorise/Vectorise/Exp.hs too large to diff
- vectorise/Vectorise/Generic/Description.hs too large to diff
- vectorise/Vectorise/Generic/PADict.hs too large to diff
- vectorise/Vectorise/Generic/PAMethods.hs too large to diff
- vectorise/Vectorise/Generic/PData.hs too large to diff
- vectorise/Vectorise/Monad.hs too large to diff
- vectorise/Vectorise/Monad/Base.hs too large to diff
- vectorise/Vectorise/Monad/Global.hs too large to diff
- vectorise/Vectorise/Monad/InstEnv.hs too large to diff
- vectorise/Vectorise/Monad/Local.hs too large to diff
- vectorise/Vectorise/Monad/Naming.hs too large to diff
- vectorise/Vectorise/Type/Classify.hs too large to diff
- vectorise/Vectorise/Type/Env.hs too large to diff
- vectorise/Vectorise/Type/TyConDecl.hs too large to diff
- vectorise/Vectorise/Type/Type.hs too large to diff
- vectorise/Vectorise/Utils.hs too large to diff
- vectorise/Vectorise/Utils/Base.hs too large to diff
- vectorise/Vectorise/Utils/Closure.hs too large to diff
- vectorise/Vectorise/Utils/Hoisting.hs too large to diff
- vectorise/Vectorise/Utils/PADict.hs too large to diff
- vectorise/Vectorise/Utils/Poly.hs too large to diff
- vectorise/Vectorise/Var.hs too large to diff
- vectorise/Vectorise/Vect.hs too large to diff
HsVersions.h view
@@ -1,5 +1,4 @@-#ifndef HSVERSIONS_H-#define HSVERSIONS_H+#pragma once #if 0 @@ -64,6 +63,3 @@ #define ASSERTM(e) do { bool <- e; MASSERT(bool) } #define ASSERTM2(e,msg) do { bool <- e; MASSERT2(bool,msg) } #define WARNM2(e,msg) do { bool <- e; WARN(bool, msg) return () }--#endif /* HsVersions.h */-
autogen/CodeGen.Platform.hs view
@@ -1,6 +1,7 @@ import CmmExpr-#if !(MACHREGS_i386 || MACHREGS_x86_64 || MACHREGS_sparc || MACHREGS_powerpc)+#if !(defined(MACHREGS_i386) || defined(MACHREGS_x86_64) \+ || defined(MACHREGS_sparc) || defined(MACHREGS_powerpc)) import Panic #endif import Reg@@ -8,9 +9,9 @@ #include "ghcautoconf.h" #include "stg/MachRegs.h" -#if MACHREGS_i386 || MACHREGS_x86_64+#if defined(MACHREGS_i386) || defined(MACHREGS_x86_64) -# if MACHREGS_i386+# if defined(MACHREGS_i386) # define eax 0 # define ebx 1 # define ecx 2@@ -21,7 +22,7 @@ # define esp 7 # endif -# if MACHREGS_x86_64+# if defined(MACHREGS_x86_64) # define rax 0 # define rbx 1 # define rcx 2@@ -103,7 +104,8 @@ -- I'm not sure if these are the correct numberings. -- Normally, the register names are just stringified as part of the REG() macro -#elif MACHREGS_powerpc || MACHREGS_arm || MACHREGS_aarch64+#elif defined(MACHREGS_powerpc) || defined(MACHREGS_arm) \+ || defined(MACHREGS_aarch64) # define r0 0 # define r1 1@@ -139,8 +141,8 @@ # define r31 31 -- See note above. These aren't actually used for anything except satisfying the compiler for globalRegMaybe--- so I'm unsure if they're the correct numberings, should they ever be attempted to be used in the NCG. -#if MACHREGS_aarch64 || MACHREGS_arm+-- so I'm unsure if they're the correct numberings, should they ever be attempted to be used in the NCG.+#if defined(MACHREGS_aarch64) || defined(MACHREGS_arm) # define s0 32 # define s1 33 # define s2 34@@ -208,7 +210,7 @@ # define d31 63 #endif -# if MACHREGS_darwin+# if defined(MACHREGS_darwin) # define f0 32 # define f1 33 # define f2 34@@ -276,7 +278,7 @@ # define fr31 63 # endif -#elif MACHREGS_sparc+#elif defined(MACHREGS_sparc) # define g0 0 # define g1 1@@ -350,278 +352,278 @@ #endif callerSaves :: GlobalReg -> Bool-#ifdef CALLER_SAVES_Base+#if defined(CALLER_SAVES_Base) callerSaves BaseReg = True #endif-#ifdef CALLER_SAVES_R1+#if defined(CALLER_SAVES_R1) callerSaves (VanillaReg 1 _) = True #endif-#ifdef CALLER_SAVES_R2+#if defined(CALLER_SAVES_R2) callerSaves (VanillaReg 2 _) = True #endif-#ifdef CALLER_SAVES_R3+#if defined(CALLER_SAVES_R3) callerSaves (VanillaReg 3 _) = True #endif-#ifdef CALLER_SAVES_R4+#if defined(CALLER_SAVES_R4) callerSaves (VanillaReg 4 _) = True #endif-#ifdef CALLER_SAVES_R5+#if defined(CALLER_SAVES_R5) callerSaves (VanillaReg 5 _) = True #endif-#ifdef CALLER_SAVES_R6+#if defined(CALLER_SAVES_R6) callerSaves (VanillaReg 6 _) = True #endif-#ifdef CALLER_SAVES_R7+#if defined(CALLER_SAVES_R7) callerSaves (VanillaReg 7 _) = True #endif-#ifdef CALLER_SAVES_R8+#if defined(CALLER_SAVES_R8) callerSaves (VanillaReg 8 _) = True #endif-#ifdef CALLER_SAVES_R9+#if defined(CALLER_SAVES_R9) callerSaves (VanillaReg 9 _) = True #endif-#ifdef CALLER_SAVES_R10+#if defined(CALLER_SAVES_R10) callerSaves (VanillaReg 10 _) = True #endif-#ifdef CALLER_SAVES_F1+#if defined(CALLER_SAVES_F1) callerSaves (FloatReg 1) = True #endif-#ifdef CALLER_SAVES_F2+#if defined(CALLER_SAVES_F2) callerSaves (FloatReg 2) = True #endif-#ifdef CALLER_SAVES_F3+#if defined(CALLER_SAVES_F3) callerSaves (FloatReg 3) = True #endif-#ifdef CALLER_SAVES_F4+#if defined(CALLER_SAVES_F4) callerSaves (FloatReg 4) = True #endif-#ifdef CALLER_SAVES_F5+#if defined(CALLER_SAVES_F5) callerSaves (FloatReg 5) = True #endif-#ifdef CALLER_SAVES_F6+#if defined(CALLER_SAVES_F6) callerSaves (FloatReg 6) = True #endif-#ifdef CALLER_SAVES_D1+#if defined(CALLER_SAVES_D1) callerSaves (DoubleReg 1) = True #endif-#ifdef CALLER_SAVES_D2+#if defined(CALLER_SAVES_D2) callerSaves (DoubleReg 2) = True #endif-#ifdef CALLER_SAVES_D3+#if defined(CALLER_SAVES_D3) callerSaves (DoubleReg 3) = True #endif-#ifdef CALLER_SAVES_D4+#if defined(CALLER_SAVES_D4) callerSaves (DoubleReg 4) = True #endif-#ifdef CALLER_SAVES_D5+#if defined(CALLER_SAVES_D5) callerSaves (DoubleReg 5) = True #endif-#ifdef CALLER_SAVES_D6+#if defined(CALLER_SAVES_D6) callerSaves (DoubleReg 6) = True #endif-#ifdef CALLER_SAVES_L1+#if defined(CALLER_SAVES_L1) callerSaves (LongReg 1) = True #endif-#ifdef CALLER_SAVES_Sp+#if defined(CALLER_SAVES_Sp) callerSaves Sp = True #endif-#ifdef CALLER_SAVES_SpLim+#if defined(CALLER_SAVES_SpLim) callerSaves SpLim = True #endif-#ifdef CALLER_SAVES_Hp+#if defined(CALLER_SAVES_Hp) callerSaves Hp = True #endif-#ifdef CALLER_SAVES_HpLim+#if defined(CALLER_SAVES_HpLim) callerSaves HpLim = True #endif-#ifdef CALLER_SAVES_CCCS+#if defined(CALLER_SAVES_CCCS) callerSaves CCCS = True #endif-#ifdef CALLER_SAVES_CurrentTSO+#if defined(CALLER_SAVES_CurrentTSO) callerSaves CurrentTSO = True #endif-#ifdef CALLER_SAVES_CurrentNursery+#if defined(CALLER_SAVES_CurrentNursery) callerSaves CurrentNursery = True #endif callerSaves _ = False activeStgRegs :: [GlobalReg] activeStgRegs = [-#ifdef REG_Base+#if defined(REG_Base) BaseReg #endif-#ifdef REG_Sp+#if defined(REG_Sp) ,Sp #endif-#ifdef REG_Hp+#if defined(REG_Hp) ,Hp #endif-#ifdef REG_R1+#if defined(REG_R1) ,VanillaReg 1 VGcPtr #endif-#ifdef REG_R2+#if defined(REG_R2) ,VanillaReg 2 VGcPtr #endif-#ifdef REG_R3+#if defined(REG_R3) ,VanillaReg 3 VGcPtr #endif-#ifdef REG_R4+#if defined(REG_R4) ,VanillaReg 4 VGcPtr #endif-#ifdef REG_R5+#if defined(REG_R5) ,VanillaReg 5 VGcPtr #endif-#ifdef REG_R6+#if defined(REG_R6) ,VanillaReg 6 VGcPtr #endif-#ifdef REG_R7+#if defined(REG_R7) ,VanillaReg 7 VGcPtr #endif-#ifdef REG_R8+#if defined(REG_R8) ,VanillaReg 8 VGcPtr #endif-#ifdef REG_R9+#if defined(REG_R9) ,VanillaReg 9 VGcPtr #endif-#ifdef REG_R10+#if defined(REG_R10) ,VanillaReg 10 VGcPtr #endif-#ifdef REG_SpLim+#if defined(REG_SpLim) ,SpLim #endif #if MAX_REAL_XMM_REG != 0-#ifdef REG_F1+#if defined(REG_F1) ,FloatReg 1 #endif-#ifdef REG_D1+#if defined(REG_D1) ,DoubleReg 1 #endif-#ifdef REG_XMM1+#if defined(REG_XMM1) ,XmmReg 1 #endif-#ifdef REG_YMM1+#if defined(REG_YMM1) ,YmmReg 1 #endif-#ifdef REG_ZMM1+#if defined(REG_ZMM1) ,ZmmReg 1 #endif-#ifdef REG_F2+#if defined(REG_F2) ,FloatReg 2 #endif-#ifdef REG_D2+#if defined(REG_D2) ,DoubleReg 2 #endif-#ifdef REG_XMM2+#if defined(REG_XMM2) ,XmmReg 2 #endif-#ifdef REG_YMM2+#if defined(REG_YMM2) ,YmmReg 2 #endif-#ifdef REG_ZMM2+#if defined(REG_ZMM2) ,ZmmReg 2 #endif-#ifdef REG_F3+#if defined(REG_F3) ,FloatReg 3 #endif-#ifdef REG_D3+#if defined(REG_D3) ,DoubleReg 3 #endif-#ifdef REG_XMM3+#if defined(REG_XMM3) ,XmmReg 3 #endif-#ifdef REG_YMM3+#if defined(REG_YMM3) ,YmmReg 3 #endif-#ifdef REG_ZMM3+#if defined(REG_ZMM3) ,ZmmReg 3 #endif-#ifdef REG_F4+#if defined(REG_F4) ,FloatReg 4 #endif-#ifdef REG_D4+#if defined(REG_D4) ,DoubleReg 4 #endif-#ifdef REG_XMM4+#if defined(REG_XMM4) ,XmmReg 4 #endif-#ifdef REG_YMM4+#if defined(REG_YMM4) ,YmmReg 4 #endif-#ifdef REG_ZMM4+#if defined(REG_ZMM4) ,ZmmReg 4 #endif-#ifdef REG_F5+#if defined(REG_F5) ,FloatReg 5 #endif-#ifdef REG_D5+#if defined(REG_D5) ,DoubleReg 5 #endif-#ifdef REG_XMM5+#if defined(REG_XMM5) ,XmmReg 5 #endif-#ifdef REG_YMM5+#if defined(REG_YMM5) ,YmmReg 5 #endif-#ifdef REG_ZMM5+#if defined(REG_ZMM5) ,ZmmReg 5 #endif-#ifdef REG_F6+#if defined(REG_F6) ,FloatReg 6 #endif-#ifdef REG_D6+#if defined(REG_D6) ,DoubleReg 6 #endif-#ifdef REG_XMM6+#if defined(REG_XMM6) ,XmmReg 6 #endif-#ifdef REG_YMM6+#if defined(REG_YMM6) ,YmmReg 6 #endif-#ifdef REG_ZMM6+#if defined(REG_ZMM6) ,ZmmReg 6 #endif #else /* MAX_REAL_XMM_REG == 0 */-#ifdef REG_F1+#if defined(REG_F1) ,FloatReg 1 #endif-#ifdef REG_F2+#if defined(REG_F2) ,FloatReg 2 #endif-#ifdef REG_F3+#if defined(REG_F3) ,FloatReg 3 #endif-#ifdef REG_F4+#if defined(REG_F4) ,FloatReg 4 #endif-#ifdef REG_F5+#if defined(REG_F5) ,FloatReg 5 #endif-#ifdef REG_F6+#if defined(REG_F6) ,FloatReg 6 #endif-#ifdef REG_D1+#if defined(REG_D1) ,DoubleReg 1 #endif-#ifdef REG_D2+#if defined(REG_D2) ,DoubleReg 2 #endif-#ifdef REG_D3+#if defined(REG_D3) ,DoubleReg 3 #endif-#ifdef REG_D4+#if defined(REG_D4) ,DoubleReg 4 #endif-#ifdef REG_D5+#if defined(REG_D5) ,DoubleReg 5 #endif-#ifdef REG_D6+#if defined(REG_D6) ,DoubleReg 6 #endif #endif /* MAX_REAL_XMM_REG == 0 */ ] haveRegBase :: Bool-#ifdef REG_Base+#if defined(REG_Base) haveRegBase = True #else haveRegBase = False@@ -631,195 +633,197 @@ -- in a real machine register, otherwise returns @'Just' reg@, where -- reg is the machine register it is stored in. globalRegMaybe :: GlobalReg -> Maybe RealReg-#if MACHREGS_i386 || MACHREGS_x86_64 || MACHREGS_sparc || MACHREGS_powerpc || MACHREGS_arm || MACHREGS_aarch64-# ifdef REG_Base+#if defined(MACHREGS_i386) || defined(MACHREGS_x86_64) \+ || defined(MACHREGS_sparc) || defined(MACHREGS_powerpc) \+ || defined(MACHREGS_arm) || defined(MACHREGS_aarch64)+# if defined(REG_Base) globalRegMaybe BaseReg = Just (RealRegSingle REG_Base) # endif-# ifdef REG_R1+# if defined(REG_R1) globalRegMaybe (VanillaReg 1 _) = Just (RealRegSingle REG_R1) # endif-# ifdef REG_R2+# if defined(REG_R2) globalRegMaybe (VanillaReg 2 _) = Just (RealRegSingle REG_R2) # endif-# ifdef REG_R3+# if defined(REG_R3) globalRegMaybe (VanillaReg 3 _) = Just (RealRegSingle REG_R3) # endif-# ifdef REG_R4+# if defined(REG_R4) globalRegMaybe (VanillaReg 4 _) = Just (RealRegSingle REG_R4) # endif-# ifdef REG_R5+# if defined(REG_R5) globalRegMaybe (VanillaReg 5 _) = Just (RealRegSingle REG_R5) # endif-# ifdef REG_R6+# if defined(REG_R6) globalRegMaybe (VanillaReg 6 _) = Just (RealRegSingle REG_R6) # endif-# ifdef REG_R7+# if defined(REG_R7) globalRegMaybe (VanillaReg 7 _) = Just (RealRegSingle REG_R7) # endif-# ifdef REG_R8+# if defined(REG_R8) globalRegMaybe (VanillaReg 8 _) = Just (RealRegSingle REG_R8) # endif-# ifdef REG_R9+# if defined(REG_R9) globalRegMaybe (VanillaReg 9 _) = Just (RealRegSingle REG_R9) # endif-# ifdef REG_R10+# if defined(REG_R10) globalRegMaybe (VanillaReg 10 _) = Just (RealRegSingle REG_R10) # endif-# ifdef REG_F1+# if defined(REG_F1) globalRegMaybe (FloatReg 1) = Just (RealRegSingle REG_F1) # endif-# ifdef REG_F2+# if defined(REG_F2) globalRegMaybe (FloatReg 2) = Just (RealRegSingle REG_F2) # endif-# ifdef REG_F3+# if defined(REG_F3) globalRegMaybe (FloatReg 3) = Just (RealRegSingle REG_F3) # endif-# ifdef REG_F4+# if defined(REG_F4) globalRegMaybe (FloatReg 4) = Just (RealRegSingle REG_F4) # endif-# ifdef REG_F5+# if defined(REG_F5) globalRegMaybe (FloatReg 5) = Just (RealRegSingle REG_F5) # endif-# ifdef REG_F6+# if defined(REG_F6) globalRegMaybe (FloatReg 6) = Just (RealRegSingle REG_F6) # endif-# ifdef REG_D1+# if defined(REG_D1) globalRegMaybe (DoubleReg 1) =-# if MACHREGS_sparc+# if defined(MACHREGS_sparc) Just (RealRegPair REG_D1 (REG_D1 + 1)) # else Just (RealRegSingle REG_D1) # endif # endif-# ifdef REG_D2+# if defined(REG_D2) globalRegMaybe (DoubleReg 2) =-# if MACHREGS_sparc+# if defined(MACHREGS_sparc) Just (RealRegPair REG_D2 (REG_D2 + 1)) # else Just (RealRegSingle REG_D2) # endif # endif-# ifdef REG_D3+# if defined(REG_D3) globalRegMaybe (DoubleReg 3) =-# if MACHREGS_sparc+# if defined(MACHREGS_sparc) Just (RealRegPair REG_D3 (REG_D3 + 1)) # else Just (RealRegSingle REG_D3) # endif # endif-# ifdef REG_D4+# if defined(REG_D4) globalRegMaybe (DoubleReg 4) =-# if MACHREGS_sparc+# if defined(MACHREGS_sparc) Just (RealRegPair REG_D4 (REG_D4 + 1)) # else Just (RealRegSingle REG_D4) # endif # endif-# ifdef REG_D5+# if defined(REG_D5) globalRegMaybe (DoubleReg 5) =-# if MACHREGS_sparc+# if defined(MACHREGS_sparc) Just (RealRegPair REG_D5 (REG_D5 + 1)) # else Just (RealRegSingle REG_D5) # endif # endif-# ifdef REG_D6+# if defined(REG_D6) globalRegMaybe (DoubleReg 6) =-# if MACHREGS_sparc+# if defined(MACHREGS_sparc) Just (RealRegPair REG_D6 (REG_D6 + 1)) # else Just (RealRegSingle REG_D6) # endif # endif # if MAX_REAL_XMM_REG != 0-# ifdef REG_XMM1+# if defined(REG_XMM1) globalRegMaybe (XmmReg 1) = Just (RealRegSingle REG_XMM1) # endif-# ifdef REG_XMM2+# if defined(REG_XMM2) globalRegMaybe (XmmReg 2) = Just (RealRegSingle REG_XMM2) # endif-# ifdef REG_XMM3+# if defined(REG_XMM3) globalRegMaybe (XmmReg 3) = Just (RealRegSingle REG_XMM3) # endif-# ifdef REG_XMM4+# if defined(REG_XMM4) globalRegMaybe (XmmReg 4) = Just (RealRegSingle REG_XMM4) # endif-# ifdef REG_XMM5+# if defined(REG_XMM5) globalRegMaybe (XmmReg 5) = Just (RealRegSingle REG_XMM5) # endif-# ifdef REG_XMM6+# if defined(REG_XMM6) globalRegMaybe (XmmReg 6) = Just (RealRegSingle REG_XMM6) # endif # endif-# if MAX_REAL_YMM_REG != 0-# ifdef REG_YMM1+# if defined(MAX_REAL_YMM_REG) && MAX_REAL_YMM_REG != 0+# if defined(REG_YMM1) globalRegMaybe (YmmReg 1) = Just (RealRegSingle REG_YMM1) # endif-# ifdef REG_YMM2+# if defined(REG_YMM2) globalRegMaybe (YmmReg 2) = Just (RealRegSingle REG_YMM2) # endif-# ifdef REG_YMM3+# if defined(REG_YMM3) globalRegMaybe (YmmReg 3) = Just (RealRegSingle REG_YMM3) # endif-# ifdef REG_YMM4+# if defined(REG_YMM4) globalRegMaybe (YmmReg 4) = Just (RealRegSingle REG_YMM4) # endif-# ifdef REG_YMM5+# if defined(REG_YMM5) globalRegMaybe (YmmReg 5) = Just (RealRegSingle REG_YMM5) # endif-# ifdef REG_YMM6+# if defined(REG_YMM6) globalRegMaybe (YmmReg 6) = Just (RealRegSingle REG_YMM6) # endif # endif-# if MAX_REAL_ZMM_REG != 0-# ifdef REG_ZMM1+# if defined(MAX_REAL_ZMM_REG) && MAX_REAL_ZMM_REG != 0+# if defined(REG_ZMM1) globalRegMaybe (ZmmReg 1) = Just (RealRegSingle REG_ZMM1) # endif-# ifdef REG_ZMM2+# if defined(REG_ZMM2) globalRegMaybe (ZmmReg 2) = Just (RealRegSingle REG_ZMM2) # endif-# ifdef REG_ZMM3+# if defined(REG_ZMM3) globalRegMaybe (ZmmReg 3) = Just (RealRegSingle REG_ZMM3) # endif-# ifdef REG_ZMM4+# if defined(REG_ZMM4) globalRegMaybe (ZmmReg 4) = Just (RealRegSingle REG_ZMM4) # endif-# ifdef REG_ZMM5+# if defined(REG_ZMM5) globalRegMaybe (ZmmReg 5) = Just (RealRegSingle REG_ZMM5) # endif-# ifdef REG_ZMM6+# if defined(REG_ZMM6) globalRegMaybe (ZmmReg 6) = Just (RealRegSingle REG_ZMM6) # endif # endif-# ifdef REG_Sp+# if defined(REG_Sp) globalRegMaybe Sp = Just (RealRegSingle REG_Sp) # endif-# ifdef REG_Lng1+# if defined(REG_Lng1) globalRegMaybe (LongReg 1) = Just (RealRegSingle REG_Lng1) # endif-# ifdef REG_Lng2+# if defined(REG_Lng2) globalRegMaybe (LongReg 2) = Just (RealRegSingle REG_Lng2) # endif-# ifdef REG_SpLim+# if defined(REG_SpLim) globalRegMaybe SpLim = Just (RealRegSingle REG_SpLim) # endif-# ifdef REG_Hp+# if defined(REG_Hp) globalRegMaybe Hp = Just (RealRegSingle REG_Hp) # endif-# ifdef REG_HpLim+# if defined(REG_HpLim) globalRegMaybe HpLim = Just (RealRegSingle REG_HpLim) # endif-# ifdef REG_CurrentTSO+# if defined(REG_CurrentTSO) globalRegMaybe CurrentTSO = Just (RealRegSingle REG_CurrentTSO) # endif-# ifdef REG_CurrentNursery+# if defined(REG_CurrentNursery) globalRegMaybe CurrentNursery = Just (RealRegSingle REG_CurrentNursery) # endif-# ifdef REG_MachSp+# if defined(REG_MachSp) globalRegMaybe MachSp = Just (RealRegSingle REG_MachSp) # endif globalRegMaybe _ = Nothing-#elif MACHREGS_NO_REGS+#elif defined(MACHREGS_NO_REGS) globalRegMaybe _ = Nothing #else globalRegMaybe = panic "globalRegMaybe not defined for this platform"@@ -827,14 +831,14 @@ freeReg :: RegNo -> Bool -#if MACHREGS_i386 || MACHREGS_x86_64+#if defined(MACHREGS_i386) || defined(MACHREGS_x86_64) -# if MACHREGS_i386+# if defined(MACHREGS_i386) freeReg esp = False -- %esp is the C stack pointer freeReg esi = False -- Note [esi/edi not allocatable] freeReg edi = False # endif-# if MACHREGS_x86_64+# if defined(MACHREGS_x86_64) freeReg rsp = False -- %rsp is the C stack pointer # endif @@ -856,33 +860,33 @@ freeReg r = freeRegBase r freeRegBase :: RegNo -> Bool-# ifdef REG_Base+# if defined(REG_Base) freeRegBase REG_Base = False # endif-# ifdef REG_Sp+# if defined(REG_Sp) freeRegBase REG_Sp = False # endif-# ifdef REG_SpLim+# if defined(REG_SpLim) freeRegBase REG_SpLim = False # endif-# ifdef REG_Hp+# if defined(REG_Hp) freeRegBase REG_Hp = False # endif-# ifdef REG_HpLim+# if defined(REG_HpLim) freeRegBase REG_HpLim = False # endif -- All other regs are considered to be "free", because we can track -- their liveness accurately. freeRegBase _ = True -#elif MACHREGS_powerpc+#elif defined(MACHREGS_powerpc) freeReg 0 = False -- Used by code setting the back chain pointer -- in stack reallocations on Linux -- r0 is not usable in all insns so also reserved -- on Darwin. freeReg 1 = False -- The Stack Pointer-# if !MACHREGS_darwin+# if !defined(MACHREGS_darwin) -- most non-darwin powerpc OSes use r2 as a TOC pointer or something like that freeReg 2 = False freeReg 13 = False -- reserved for system thread ID on 64 bit@@ -897,93 +901,93 @@ -} # endif-# ifdef REG_Base+# if defined(REG_Base) freeReg REG_Base = False # endif-# ifdef REG_R1+# if defined(REG_R1) freeReg REG_R1 = False # endif-# ifdef REG_R2+# if defined(REG_R2) freeReg REG_R2 = False # endif-# ifdef REG_R3+# if defined(REG_R3) freeReg REG_R3 = False # endif-# ifdef REG_R4+# if defined(REG_R4) freeReg REG_R4 = False # endif-# ifdef REG_R5+# if defined(REG_R5) freeReg REG_R5 = False # endif-# ifdef REG_R6+# if defined(REG_R6) freeReg REG_R6 = False # endif-# ifdef REG_R7+# if defined(REG_R7) freeReg REG_R7 = False # endif-# ifdef REG_R8+# if defined(REG_R8) freeReg REG_R8 = False # endif-# ifdef REG_R9+# if defined(REG_R9) freeReg REG_R9 = False # endif-# ifdef REG_R10+# if defined(REG_R10) freeReg REG_R10 = False # endif-# ifdef REG_F1+# if defined(REG_F1) freeReg REG_F1 = False # endif-# ifdef REG_F2+# if defined(REG_F2) freeReg REG_F2 = False # endif-# ifdef REG_F3+# if defined(REG_F3) freeReg REG_F3 = False # endif-# ifdef REG_F4+# if defined(REG_F4) freeReg REG_F4 = False # endif-# ifdef REG_F5+# if defined(REG_F5) freeReg REG_F5 = False # endif-# ifdef REG_F6+# if defined(REG_F6) freeReg REG_F6 = False # endif-# ifdef REG_D1+# if defined(REG_D1) freeReg REG_D1 = False # endif-# ifdef REG_D2+# if defined(REG_D2) freeReg REG_D2 = False # endif-# ifdef REG_D3+# if defined(REG_D3) freeReg REG_D3 = False # endif-# ifdef REG_D4+# if defined(REG_D4) freeReg REG_D4 = False # endif-# ifdef REG_D5+# if defined(REG_D5) freeReg REG_D5 = False # endif-# ifdef REG_D6+# if defined(REG_D6) freeReg REG_D6 = False # endif-# ifdef REG_Sp+# if defined(REG_Sp) freeReg REG_Sp = False # endif-# ifdef REG_Su+# if defined(REG_Su) freeReg REG_Su = False # endif-# ifdef REG_SpLim+# if defined(REG_SpLim) freeReg REG_SpLim = False # endif-# ifdef REG_Hp+# if defined(REG_Hp) freeReg REG_Hp = False # endif-# ifdef REG_HpLim+# if defined(REG_HpLim) freeReg REG_HpLim = False # endif freeReg _ = True -#elif MACHREGS_sparc+#elif defined(MACHREGS_sparc) -- SPARC regs used by the OS / ABI -- %g0(r0) is always zero@@ -1025,106 +1029,106 @@ = False -} -# ifdef REG_Base+# if defined(REG_Base) freeReg REG_Base = False # endif-# ifdef REG_R1+# if defined(REG_R1) freeReg REG_R1 = False # endif-# ifdef REG_R2+# if defined(REG_R2) freeReg REG_R2 = False # endif-# ifdef REG_R3+# if defined(REG_R3) freeReg REG_R3 = False # endif-# ifdef REG_R4+# if defined(REG_R4) freeReg REG_R4 = False # endif-# ifdef REG_R5+# if defined(REG_R5) freeReg REG_R5 = False # endif-# ifdef REG_R6+# if defined(REG_R6) freeReg REG_R6 = False # endif-# ifdef REG_R7+# if defined(REG_R7) freeReg REG_R7 = False # endif-# ifdef REG_R8+# if defined(REG_R8) freeReg REG_R8 = False # endif-# ifdef REG_R9+# if defined(REG_R9) freeReg REG_R9 = False # endif-# ifdef REG_R10+# if defined(REG_R10) freeReg REG_R10 = False # endif-# ifdef REG_F1+# if defined(REG_F1) freeReg REG_F1 = False # endif-# ifdef REG_F2+# if defined(REG_F2) freeReg REG_F2 = False # endif-# ifdef REG_F3+# if defined(REG_F3) freeReg REG_F3 = False # endif-# ifdef REG_F4+# if defined(REG_F4) freeReg REG_F4 = False # endif-# ifdef REG_F5+# if defined(REG_F5) freeReg REG_F5 = False # endif-# ifdef REG_F6+# if defined(REG_F6) freeReg REG_F6 = False # endif-# ifdef REG_D1+# if defined(REG_D1) freeReg REG_D1 = False # endif-# ifdef REG_D1_2+# if defined(REG_D1_2) freeReg REG_D1_2 = False # endif-# ifdef REG_D2+# if defined(REG_D2) freeReg REG_D2 = False # endif-# ifdef REG_D2_2+# if defined(REG_D2_2) freeReg REG_D2_2 = False # endif-# ifdef REG_D3+# if defined(REG_D3) freeReg REG_D3 = False # endif-# ifdef REG_D3_2+# if defined(REG_D3_2) freeReg REG_D3_2 = False # endif-# ifdef REG_D4+# if defined(REG_D4) freeReg REG_D4 = False # endif-# ifdef REG_D4_2+# if defined(REG_D4_2) freeReg REG_D4_2 = False # endif-# ifdef REG_D5+# if defined(REG_D5) freeReg REG_D5 = False # endif-# ifdef REG_D5_2+# if defined(REG_D5_2) freeReg REG_D5_2 = False # endif-# ifdef REG_D6+# if defined(REG_D6) freeReg REG_D6 = False # endif-# ifdef REG_D6_2+# if defined(REG_D6_2) freeReg REG_D6_2 = False # endif-# ifdef REG_Sp+# if defined(REG_Sp) freeReg REG_Sp = False # endif-# ifdef REG_Su+# if defined(REG_Su) freeReg REG_Su = False # endif-# ifdef REG_SpLim+# if defined(REG_SpLim) freeReg REG_SpLim = False # endif-# ifdef REG_Hp+# if defined(REG_Hp) freeReg REG_Hp = False # endif-# ifdef REG_HpLim+# if defined(REG_HpLim) freeReg REG_HpLim = False # endif freeReg _ = True
autogen/Config.hs view
@@ -1,6 +1,8 @@ {-# LANGUAGE CPP #-} module Config where +import GhcPrelude+ #include "ghc_boot_platform.h" data IntegerLibrary = IntegerGMP@@ -17,19 +19,19 @@ cProjectName :: String cProjectName = "The Glorious Glasgow Haskell Compilation System" cProjectGitCommitId :: String-cProjectGitCommitId = "0156a3d815b784510a980621fdcb9c5b23826f1e"+cProjectGitCommitId = "f31c40efdc918bc9da8a325327ba5a472bd6ea9e" cProjectVersion :: String-cProjectVersion = "8.2.2"+cProjectVersion = "8.4.1" cProjectVersionInt :: String-cProjectVersionInt = "802"+cProjectVersionInt = "804" cProjectPatchLevel :: String-cProjectPatchLevel = "2"+cProjectPatchLevel = "1" cProjectPatchLevel1 :: String-cProjectPatchLevel1 = "2"+cProjectPatchLevel1 = "1" cProjectPatchLevel2 :: String cProjectPatchLevel2 = "" cBooterVersion :: String-cBooterVersion = "8.0.2"+cBooterVersion = "8.2.2" cStage :: String cStage = show (STAGE :: Int) cIntegerLibrary :: String
autogen/ghc_boot_platform.h view
@@ -15,6 +15,7 @@ #define BUILD_ARCH "x86_64" #define HOST_ARCH "x86_64" #define TARGET_ARCH "x86_64"+#define LLVM_TARGET "x86_64-unknown-linux" #define linux_BUILD_OS 1 #define linux_HOST_OS 1
autogen/primop-can-fail.hs-incl view
@@ -79,6 +79,7 @@ primOpCanFail WriteByteArrayOp_Word16 = True primOpCanFail WriteByteArrayOp_Word32 = True primOpCanFail WriteByteArrayOp_Word64 = True+primOpCanFail CompareByteArraysOp = True primOpCanFail CopyByteArrayOp = True primOpCanFail CopyMutableByteArrayOp = True primOpCanFail CopyByteArrayToAddrOp = True@@ -154,8 +155,6 @@ primOpCanFail WriteOffAddrOp_Word16 = True primOpCanFail WriteOffAddrOp_Word32 = True primOpCanFail WriteOffAddrOp_Word64 = True-primOpCanFail ReadMutVarOp = True-primOpCanFail WriteMutVarOp = True primOpCanFail AtomicModifyMutVarOp = True primOpCanFail ReallyUnsafePtrEqualityOp = True primOpCanFail DataToTagOp = True
autogen/primop-data-decl.hs-incl view
@@ -63,6 +63,16 @@ | PopCnt32Op | PopCnt64Op | PopCntOp+ | Pdep8Op+ | Pdep16Op+ | Pdep32Op+ | Pdep64Op+ | PdepOp+ | Pext8Op+ | Pext16Op+ | Pext32Op+ | Pext64Op+ | PextOp | Clz8Op | Clz16Op | Clz32Op@@ -233,6 +243,7 @@ | WriteByteArrayOp_Word16 | WriteByteArrayOp_Word32 | WriteByteArrayOp_Word64+ | CompareByteArraysOp | CopyByteArrayOp | CopyMutableByteArrayOp | CopyByteArrayToAddrOp
autogen/primop-list.hs-incl view
@@ -62,6 +62,16 @@ , PopCnt32Op , PopCnt64Op , PopCntOp+ , Pdep8Op+ , Pdep16Op+ , Pdep32Op+ , Pdep64Op+ , PdepOp+ , Pext8Op+ , Pext16Op+ , Pext32Op+ , Pext64Op+ , PextOp , Clz8Op , Clz16Op , Clz32Op@@ -232,6 +242,7 @@ , WriteByteArrayOp_Word16 , WriteByteArrayOp_Word32 , WriteByteArrayOp_Word64+ , CompareByteArraysOp , CopyByteArrayOp , CopyMutableByteArrayOp , CopyByteArrayToAddrOp
autogen/primop-primop-info.hs-incl view
@@ -62,6 +62,16 @@ primOpInfo PopCnt32Op = mkMonadic (fsLit "popCnt32#") wordPrimTy primOpInfo PopCnt64Op = mkGenPrimOp (fsLit "popCnt64#") [] [wordPrimTy] (wordPrimTy) primOpInfo PopCntOp = mkMonadic (fsLit "popCnt#") wordPrimTy+primOpInfo Pdep8Op = mkDyadic (fsLit "pdep8#") wordPrimTy+primOpInfo Pdep16Op = mkDyadic (fsLit "pdep16#") wordPrimTy+primOpInfo Pdep32Op = mkDyadic (fsLit "pdep32#") wordPrimTy+primOpInfo Pdep64Op = mkGenPrimOp (fsLit "pdep64#") [] [wordPrimTy, wordPrimTy] (wordPrimTy)+primOpInfo PdepOp = mkDyadic (fsLit "pdep#") wordPrimTy+primOpInfo Pext8Op = mkDyadic (fsLit "pext8#") wordPrimTy+primOpInfo Pext16Op = mkDyadic (fsLit "pext16#") wordPrimTy+primOpInfo Pext32Op = mkDyadic (fsLit "pext32#") wordPrimTy+primOpInfo Pext64Op = mkGenPrimOp (fsLit "pext64#") [] [wordPrimTy, wordPrimTy] (wordPrimTy)+primOpInfo PextOp = mkDyadic (fsLit "pext#") wordPrimTy primOpInfo Clz8Op = mkMonadic (fsLit "clz8#") wordPrimTy primOpInfo Clz16Op = mkMonadic (fsLit "clz16#") wordPrimTy primOpInfo Clz32Op = mkMonadic (fsLit "clz32#") wordPrimTy@@ -232,6 +242,7 @@ primOpInfo WriteByteArrayOp_Word16 = mkGenPrimOp (fsLit "writeWord16Array#") [deltaTyVar] [mkMutableByteArrayPrimTy deltaTy, intPrimTy, wordPrimTy, mkStatePrimTy deltaTy] (mkStatePrimTy deltaTy) primOpInfo WriteByteArrayOp_Word32 = mkGenPrimOp (fsLit "writeWord32Array#") [deltaTyVar] [mkMutableByteArrayPrimTy deltaTy, intPrimTy, wordPrimTy, mkStatePrimTy deltaTy] (mkStatePrimTy deltaTy) primOpInfo WriteByteArrayOp_Word64 = mkGenPrimOp (fsLit "writeWord64Array#") [deltaTyVar] [mkMutableByteArrayPrimTy deltaTy, intPrimTy, wordPrimTy, mkStatePrimTy deltaTy] (mkStatePrimTy deltaTy)+primOpInfo CompareByteArraysOp = mkGenPrimOp (fsLit "compareByteArrays#") [] [byteArrayPrimTy, intPrimTy, byteArrayPrimTy, intPrimTy, intPrimTy] (intPrimTy) primOpInfo CopyByteArrayOp = mkGenPrimOp (fsLit "copyByteArray#") [deltaTyVar] [byteArrayPrimTy, intPrimTy, mkMutableByteArrayPrimTy deltaTy, intPrimTy, intPrimTy, mkStatePrimTy deltaTy] (mkStatePrimTy deltaTy) primOpInfo CopyMutableByteArrayOp = mkGenPrimOp (fsLit "copyMutableByteArray#") [deltaTyVar] [mkMutableByteArrayPrimTy deltaTy, intPrimTy, mkMutableByteArrayPrimTy deltaTy, intPrimTy, intPrimTy, mkStatePrimTy deltaTy] (mkStatePrimTy deltaTy) primOpInfo CopyByteArrayToAddrOp = mkGenPrimOp (fsLit "copyByteArrayToAddr#") [deltaTyVar] [byteArrayPrimTy, intPrimTy, addrPrimTy, intPrimTy, mkStatePrimTy deltaTy] (mkStatePrimTy deltaTy)
autogen/primop-tag.hs-incl view
@@ -1,1072 +1,1083 @@ maxPrimOpTag :: Int-maxPrimOpTag = 1069-primOpTag :: PrimOp -> Int-primOpTag CharGtOp = 1-primOpTag CharGeOp = 2-primOpTag CharEqOp = 3-primOpTag CharNeOp = 4-primOpTag CharLtOp = 5-primOpTag CharLeOp = 6-primOpTag OrdOp = 7-primOpTag IntAddOp = 8-primOpTag IntSubOp = 9-primOpTag IntMulOp = 10-primOpTag IntMulMayOfloOp = 11-primOpTag IntQuotOp = 12-primOpTag IntRemOp = 13-primOpTag IntQuotRemOp = 14-primOpTag AndIOp = 15-primOpTag OrIOp = 16-primOpTag XorIOp = 17-primOpTag NotIOp = 18-primOpTag IntNegOp = 19-primOpTag IntAddCOp = 20-primOpTag IntSubCOp = 21-primOpTag IntGtOp = 22-primOpTag IntGeOp = 23-primOpTag IntEqOp = 24-primOpTag IntNeOp = 25-primOpTag IntLtOp = 26-primOpTag IntLeOp = 27-primOpTag ChrOp = 28-primOpTag Int2WordOp = 29-primOpTag Int2FloatOp = 30-primOpTag Int2DoubleOp = 31-primOpTag Word2FloatOp = 32-primOpTag Word2DoubleOp = 33-primOpTag ISllOp = 34-primOpTag ISraOp = 35-primOpTag ISrlOp = 36-primOpTag WordAddOp = 37-primOpTag WordSubCOp = 38-primOpTag WordAdd2Op = 39-primOpTag WordSubOp = 40-primOpTag WordMulOp = 41-primOpTag WordMul2Op = 42-primOpTag WordQuotOp = 43-primOpTag WordRemOp = 44-primOpTag WordQuotRemOp = 45-primOpTag WordQuotRem2Op = 46-primOpTag AndOp = 47-primOpTag OrOp = 48-primOpTag XorOp = 49-primOpTag NotOp = 50-primOpTag SllOp = 51-primOpTag SrlOp = 52-primOpTag Word2IntOp = 53-primOpTag WordGtOp = 54-primOpTag WordGeOp = 55-primOpTag WordEqOp = 56-primOpTag WordNeOp = 57-primOpTag WordLtOp = 58-primOpTag WordLeOp = 59-primOpTag PopCnt8Op = 60-primOpTag PopCnt16Op = 61-primOpTag PopCnt32Op = 62-primOpTag PopCnt64Op = 63-primOpTag PopCntOp = 64-primOpTag Clz8Op = 65-primOpTag Clz16Op = 66-primOpTag Clz32Op = 67-primOpTag Clz64Op = 68-primOpTag ClzOp = 69-primOpTag Ctz8Op = 70-primOpTag Ctz16Op = 71-primOpTag Ctz32Op = 72-primOpTag Ctz64Op = 73-primOpTag CtzOp = 74-primOpTag BSwap16Op = 75-primOpTag BSwap32Op = 76-primOpTag BSwap64Op = 77-primOpTag BSwapOp = 78-primOpTag Narrow8IntOp = 79-primOpTag Narrow16IntOp = 80-primOpTag Narrow32IntOp = 81-primOpTag Narrow8WordOp = 82-primOpTag Narrow16WordOp = 83-primOpTag Narrow32WordOp = 84-primOpTag DoubleGtOp = 85-primOpTag DoubleGeOp = 86-primOpTag DoubleEqOp = 87-primOpTag DoubleNeOp = 88-primOpTag DoubleLtOp = 89-primOpTag DoubleLeOp = 90-primOpTag DoubleAddOp = 91-primOpTag DoubleSubOp = 92-primOpTag DoubleMulOp = 93-primOpTag DoubleDivOp = 94-primOpTag DoubleNegOp = 95-primOpTag DoubleFabsOp = 96-primOpTag Double2IntOp = 97-primOpTag Double2FloatOp = 98-primOpTag DoubleExpOp = 99-primOpTag DoubleLogOp = 100-primOpTag DoubleSqrtOp = 101-primOpTag DoubleSinOp = 102-primOpTag DoubleCosOp = 103-primOpTag DoubleTanOp = 104-primOpTag DoubleAsinOp = 105-primOpTag DoubleAcosOp = 106-primOpTag DoubleAtanOp = 107-primOpTag DoubleSinhOp = 108-primOpTag DoubleCoshOp = 109-primOpTag DoubleTanhOp = 110-primOpTag DoublePowerOp = 111-primOpTag DoubleDecode_2IntOp = 112-primOpTag DoubleDecode_Int64Op = 113-primOpTag FloatGtOp = 114-primOpTag FloatGeOp = 115-primOpTag FloatEqOp = 116-primOpTag FloatNeOp = 117-primOpTag FloatLtOp = 118-primOpTag FloatLeOp = 119-primOpTag FloatAddOp = 120-primOpTag FloatSubOp = 121-primOpTag FloatMulOp = 122-primOpTag FloatDivOp = 123-primOpTag FloatNegOp = 124-primOpTag FloatFabsOp = 125-primOpTag Float2IntOp = 126-primOpTag FloatExpOp = 127-primOpTag FloatLogOp = 128-primOpTag FloatSqrtOp = 129-primOpTag FloatSinOp = 130-primOpTag FloatCosOp = 131-primOpTag FloatTanOp = 132-primOpTag FloatAsinOp = 133-primOpTag FloatAcosOp = 134-primOpTag FloatAtanOp = 135-primOpTag FloatSinhOp = 136-primOpTag FloatCoshOp = 137-primOpTag FloatTanhOp = 138-primOpTag FloatPowerOp = 139-primOpTag Float2DoubleOp = 140-primOpTag FloatDecode_IntOp = 141-primOpTag NewArrayOp = 142-primOpTag SameMutableArrayOp = 143-primOpTag ReadArrayOp = 144-primOpTag WriteArrayOp = 145-primOpTag SizeofArrayOp = 146-primOpTag SizeofMutableArrayOp = 147-primOpTag IndexArrayOp = 148-primOpTag UnsafeFreezeArrayOp = 149-primOpTag UnsafeThawArrayOp = 150-primOpTag CopyArrayOp = 151-primOpTag CopyMutableArrayOp = 152-primOpTag CloneArrayOp = 153-primOpTag CloneMutableArrayOp = 154-primOpTag FreezeArrayOp = 155-primOpTag ThawArrayOp = 156-primOpTag CasArrayOp = 157-primOpTag NewSmallArrayOp = 158-primOpTag SameSmallMutableArrayOp = 159-primOpTag ReadSmallArrayOp = 160-primOpTag WriteSmallArrayOp = 161-primOpTag SizeofSmallArrayOp = 162-primOpTag SizeofSmallMutableArrayOp = 163-primOpTag IndexSmallArrayOp = 164-primOpTag UnsafeFreezeSmallArrayOp = 165-primOpTag UnsafeThawSmallArrayOp = 166-primOpTag CopySmallArrayOp = 167-primOpTag CopySmallMutableArrayOp = 168-primOpTag CloneSmallArrayOp = 169-primOpTag CloneSmallMutableArrayOp = 170-primOpTag FreezeSmallArrayOp = 171-primOpTag ThawSmallArrayOp = 172-primOpTag CasSmallArrayOp = 173-primOpTag NewByteArrayOp_Char = 174-primOpTag NewPinnedByteArrayOp_Char = 175-primOpTag NewAlignedPinnedByteArrayOp_Char = 176-primOpTag MutableByteArrayIsPinnedOp = 177-primOpTag ByteArrayIsPinnedOp = 178-primOpTag ByteArrayContents_Char = 179-primOpTag SameMutableByteArrayOp = 180-primOpTag ShrinkMutableByteArrayOp_Char = 181-primOpTag ResizeMutableByteArrayOp_Char = 182-primOpTag UnsafeFreezeByteArrayOp = 183-primOpTag SizeofByteArrayOp = 184-primOpTag SizeofMutableByteArrayOp = 185-primOpTag GetSizeofMutableByteArrayOp = 186-primOpTag IndexByteArrayOp_Char = 187-primOpTag IndexByteArrayOp_WideChar = 188-primOpTag IndexByteArrayOp_Int = 189-primOpTag IndexByteArrayOp_Word = 190-primOpTag IndexByteArrayOp_Addr = 191-primOpTag IndexByteArrayOp_Float = 192-primOpTag IndexByteArrayOp_Double = 193-primOpTag IndexByteArrayOp_StablePtr = 194-primOpTag IndexByteArrayOp_Int8 = 195-primOpTag IndexByteArrayOp_Int16 = 196-primOpTag IndexByteArrayOp_Int32 = 197-primOpTag IndexByteArrayOp_Int64 = 198-primOpTag IndexByteArrayOp_Word8 = 199-primOpTag IndexByteArrayOp_Word16 = 200-primOpTag IndexByteArrayOp_Word32 = 201-primOpTag IndexByteArrayOp_Word64 = 202-primOpTag ReadByteArrayOp_Char = 203-primOpTag ReadByteArrayOp_WideChar = 204-primOpTag ReadByteArrayOp_Int = 205-primOpTag ReadByteArrayOp_Word = 206-primOpTag ReadByteArrayOp_Addr = 207-primOpTag ReadByteArrayOp_Float = 208-primOpTag ReadByteArrayOp_Double = 209-primOpTag ReadByteArrayOp_StablePtr = 210-primOpTag ReadByteArrayOp_Int8 = 211-primOpTag ReadByteArrayOp_Int16 = 212-primOpTag ReadByteArrayOp_Int32 = 213-primOpTag ReadByteArrayOp_Int64 = 214-primOpTag ReadByteArrayOp_Word8 = 215-primOpTag ReadByteArrayOp_Word16 = 216-primOpTag ReadByteArrayOp_Word32 = 217-primOpTag ReadByteArrayOp_Word64 = 218-primOpTag WriteByteArrayOp_Char = 219-primOpTag WriteByteArrayOp_WideChar = 220-primOpTag WriteByteArrayOp_Int = 221-primOpTag WriteByteArrayOp_Word = 222-primOpTag WriteByteArrayOp_Addr = 223-primOpTag WriteByteArrayOp_Float = 224-primOpTag WriteByteArrayOp_Double = 225-primOpTag WriteByteArrayOp_StablePtr = 226-primOpTag WriteByteArrayOp_Int8 = 227-primOpTag WriteByteArrayOp_Int16 = 228-primOpTag WriteByteArrayOp_Int32 = 229-primOpTag WriteByteArrayOp_Int64 = 230-primOpTag WriteByteArrayOp_Word8 = 231-primOpTag WriteByteArrayOp_Word16 = 232-primOpTag WriteByteArrayOp_Word32 = 233-primOpTag WriteByteArrayOp_Word64 = 234-primOpTag CopyByteArrayOp = 235-primOpTag CopyMutableByteArrayOp = 236-primOpTag CopyByteArrayToAddrOp = 237-primOpTag CopyMutableByteArrayToAddrOp = 238-primOpTag CopyAddrToByteArrayOp = 239-primOpTag SetByteArrayOp = 240-primOpTag AtomicReadByteArrayOp_Int = 241-primOpTag AtomicWriteByteArrayOp_Int = 242-primOpTag CasByteArrayOp_Int = 243-primOpTag FetchAddByteArrayOp_Int = 244-primOpTag FetchSubByteArrayOp_Int = 245-primOpTag FetchAndByteArrayOp_Int = 246-primOpTag FetchNandByteArrayOp_Int = 247-primOpTag FetchOrByteArrayOp_Int = 248-primOpTag FetchXorByteArrayOp_Int = 249-primOpTag NewArrayArrayOp = 250-primOpTag SameMutableArrayArrayOp = 251-primOpTag UnsafeFreezeArrayArrayOp = 252-primOpTag SizeofArrayArrayOp = 253-primOpTag SizeofMutableArrayArrayOp = 254-primOpTag IndexArrayArrayOp_ByteArray = 255-primOpTag IndexArrayArrayOp_ArrayArray = 256-primOpTag ReadArrayArrayOp_ByteArray = 257-primOpTag ReadArrayArrayOp_MutableByteArray = 258-primOpTag ReadArrayArrayOp_ArrayArray = 259-primOpTag ReadArrayArrayOp_MutableArrayArray = 260-primOpTag WriteArrayArrayOp_ByteArray = 261-primOpTag WriteArrayArrayOp_MutableByteArray = 262-primOpTag WriteArrayArrayOp_ArrayArray = 263-primOpTag WriteArrayArrayOp_MutableArrayArray = 264-primOpTag CopyArrayArrayOp = 265-primOpTag CopyMutableArrayArrayOp = 266-primOpTag AddrAddOp = 267-primOpTag AddrSubOp = 268-primOpTag AddrRemOp = 269-primOpTag Addr2IntOp = 270-primOpTag Int2AddrOp = 271-primOpTag AddrGtOp = 272-primOpTag AddrGeOp = 273-primOpTag AddrEqOp = 274-primOpTag AddrNeOp = 275-primOpTag AddrLtOp = 276-primOpTag AddrLeOp = 277-primOpTag IndexOffAddrOp_Char = 278-primOpTag IndexOffAddrOp_WideChar = 279-primOpTag IndexOffAddrOp_Int = 280-primOpTag IndexOffAddrOp_Word = 281-primOpTag IndexOffAddrOp_Addr = 282-primOpTag IndexOffAddrOp_Float = 283-primOpTag IndexOffAddrOp_Double = 284-primOpTag IndexOffAddrOp_StablePtr = 285-primOpTag IndexOffAddrOp_Int8 = 286-primOpTag IndexOffAddrOp_Int16 = 287-primOpTag IndexOffAddrOp_Int32 = 288-primOpTag IndexOffAddrOp_Int64 = 289-primOpTag IndexOffAddrOp_Word8 = 290-primOpTag IndexOffAddrOp_Word16 = 291-primOpTag IndexOffAddrOp_Word32 = 292-primOpTag IndexOffAddrOp_Word64 = 293-primOpTag ReadOffAddrOp_Char = 294-primOpTag ReadOffAddrOp_WideChar = 295-primOpTag ReadOffAddrOp_Int = 296-primOpTag ReadOffAddrOp_Word = 297-primOpTag ReadOffAddrOp_Addr = 298-primOpTag ReadOffAddrOp_Float = 299-primOpTag ReadOffAddrOp_Double = 300-primOpTag ReadOffAddrOp_StablePtr = 301-primOpTag ReadOffAddrOp_Int8 = 302-primOpTag ReadOffAddrOp_Int16 = 303-primOpTag ReadOffAddrOp_Int32 = 304-primOpTag ReadOffAddrOp_Int64 = 305-primOpTag ReadOffAddrOp_Word8 = 306-primOpTag ReadOffAddrOp_Word16 = 307-primOpTag ReadOffAddrOp_Word32 = 308-primOpTag ReadOffAddrOp_Word64 = 309-primOpTag WriteOffAddrOp_Char = 310-primOpTag WriteOffAddrOp_WideChar = 311-primOpTag WriteOffAddrOp_Int = 312-primOpTag WriteOffAddrOp_Word = 313-primOpTag WriteOffAddrOp_Addr = 314-primOpTag WriteOffAddrOp_Float = 315-primOpTag WriteOffAddrOp_Double = 316-primOpTag WriteOffAddrOp_StablePtr = 317-primOpTag WriteOffAddrOp_Int8 = 318-primOpTag WriteOffAddrOp_Int16 = 319-primOpTag WriteOffAddrOp_Int32 = 320-primOpTag WriteOffAddrOp_Int64 = 321-primOpTag WriteOffAddrOp_Word8 = 322-primOpTag WriteOffAddrOp_Word16 = 323-primOpTag WriteOffAddrOp_Word32 = 324-primOpTag WriteOffAddrOp_Word64 = 325-primOpTag NewMutVarOp = 326-primOpTag ReadMutVarOp = 327-primOpTag WriteMutVarOp = 328-primOpTag SameMutVarOp = 329-primOpTag AtomicModifyMutVarOp = 330-primOpTag CasMutVarOp = 331-primOpTag CatchOp = 332-primOpTag RaiseOp = 333-primOpTag RaiseIOOp = 334-primOpTag MaskAsyncExceptionsOp = 335-primOpTag MaskUninterruptibleOp = 336-primOpTag UnmaskAsyncExceptionsOp = 337-primOpTag MaskStatus = 338-primOpTag AtomicallyOp = 339-primOpTag RetryOp = 340-primOpTag CatchRetryOp = 341-primOpTag CatchSTMOp = 342-primOpTag Check = 343-primOpTag NewTVarOp = 344-primOpTag ReadTVarOp = 345-primOpTag ReadTVarIOOp = 346-primOpTag WriteTVarOp = 347-primOpTag SameTVarOp = 348-primOpTag NewMVarOp = 349-primOpTag TakeMVarOp = 350-primOpTag TryTakeMVarOp = 351-primOpTag PutMVarOp = 352-primOpTag TryPutMVarOp = 353-primOpTag ReadMVarOp = 354-primOpTag TryReadMVarOp = 355-primOpTag SameMVarOp = 356-primOpTag IsEmptyMVarOp = 357-primOpTag DelayOp = 358-primOpTag WaitReadOp = 359-primOpTag WaitWriteOp = 360-primOpTag ForkOp = 361-primOpTag ForkOnOp = 362-primOpTag KillThreadOp = 363-primOpTag YieldOp = 364-primOpTag MyThreadIdOp = 365-primOpTag LabelThreadOp = 366-primOpTag IsCurrentThreadBoundOp = 367-primOpTag NoDuplicateOp = 368-primOpTag ThreadStatusOp = 369-primOpTag MkWeakOp = 370-primOpTag MkWeakNoFinalizerOp = 371-primOpTag AddCFinalizerToWeakOp = 372-primOpTag DeRefWeakOp = 373-primOpTag FinalizeWeakOp = 374-primOpTag TouchOp = 375-primOpTag MakeStablePtrOp = 376-primOpTag DeRefStablePtrOp = 377-primOpTag EqStablePtrOp = 378-primOpTag MakeStableNameOp = 379-primOpTag EqStableNameOp = 380-primOpTag StableNameToIntOp = 381-primOpTag CompactNewOp = 382-primOpTag CompactResizeOp = 383-primOpTag CompactContainsOp = 384-primOpTag CompactContainsAnyOp = 385-primOpTag CompactGetFirstBlockOp = 386-primOpTag CompactGetNextBlockOp = 387-primOpTag CompactAllocateBlockOp = 388-primOpTag CompactFixupPointersOp = 389-primOpTag CompactAdd = 390-primOpTag CompactAddWithSharing = 391-primOpTag CompactSize = 392-primOpTag ReallyUnsafePtrEqualityOp = 393-primOpTag ParOp = 394-primOpTag SparkOp = 395-primOpTag SeqOp = 396-primOpTag GetSparkOp = 397-primOpTag NumSparks = 398-primOpTag DataToTagOp = 399-primOpTag TagToEnumOp = 400-primOpTag AddrToAnyOp = 401-primOpTag AnyToAddrOp = 402-primOpTag MkApUpd0_Op = 403-primOpTag NewBCOOp = 404-primOpTag UnpackClosureOp = 405-primOpTag GetApStackValOp = 406-primOpTag GetCCSOfOp = 407-primOpTag GetCurrentCCSOp = 408-primOpTag ClearCCSOp = 409-primOpTag TraceEventOp = 410-primOpTag TraceMarkerOp = 411-primOpTag (VecBroadcastOp IntVec 16 W8) = 412-primOpTag (VecBroadcastOp IntVec 8 W16) = 413-primOpTag (VecBroadcastOp IntVec 4 W32) = 414-primOpTag (VecBroadcastOp IntVec 2 W64) = 415-primOpTag (VecBroadcastOp IntVec 32 W8) = 416-primOpTag (VecBroadcastOp IntVec 16 W16) = 417-primOpTag (VecBroadcastOp IntVec 8 W32) = 418-primOpTag (VecBroadcastOp IntVec 4 W64) = 419-primOpTag (VecBroadcastOp IntVec 64 W8) = 420-primOpTag (VecBroadcastOp IntVec 32 W16) = 421-primOpTag (VecBroadcastOp IntVec 16 W32) = 422-primOpTag (VecBroadcastOp IntVec 8 W64) = 423-primOpTag (VecBroadcastOp WordVec 16 W8) = 424-primOpTag (VecBroadcastOp WordVec 8 W16) = 425-primOpTag (VecBroadcastOp WordVec 4 W32) = 426-primOpTag (VecBroadcastOp WordVec 2 W64) = 427-primOpTag (VecBroadcastOp WordVec 32 W8) = 428-primOpTag (VecBroadcastOp WordVec 16 W16) = 429-primOpTag (VecBroadcastOp WordVec 8 W32) = 430-primOpTag (VecBroadcastOp WordVec 4 W64) = 431-primOpTag (VecBroadcastOp WordVec 64 W8) = 432-primOpTag (VecBroadcastOp WordVec 32 W16) = 433-primOpTag (VecBroadcastOp WordVec 16 W32) = 434-primOpTag (VecBroadcastOp WordVec 8 W64) = 435-primOpTag (VecBroadcastOp FloatVec 4 W32) = 436-primOpTag (VecBroadcastOp FloatVec 2 W64) = 437-primOpTag (VecBroadcastOp FloatVec 8 W32) = 438-primOpTag (VecBroadcastOp FloatVec 4 W64) = 439-primOpTag (VecBroadcastOp FloatVec 16 W32) = 440-primOpTag (VecBroadcastOp FloatVec 8 W64) = 441-primOpTag (VecPackOp IntVec 16 W8) = 442-primOpTag (VecPackOp IntVec 8 W16) = 443-primOpTag (VecPackOp IntVec 4 W32) = 444-primOpTag (VecPackOp IntVec 2 W64) = 445-primOpTag (VecPackOp IntVec 32 W8) = 446-primOpTag (VecPackOp IntVec 16 W16) = 447-primOpTag (VecPackOp IntVec 8 W32) = 448-primOpTag (VecPackOp IntVec 4 W64) = 449-primOpTag (VecPackOp IntVec 64 W8) = 450-primOpTag (VecPackOp IntVec 32 W16) = 451-primOpTag (VecPackOp IntVec 16 W32) = 452-primOpTag (VecPackOp IntVec 8 W64) = 453-primOpTag (VecPackOp WordVec 16 W8) = 454-primOpTag (VecPackOp WordVec 8 W16) = 455-primOpTag (VecPackOp WordVec 4 W32) = 456-primOpTag (VecPackOp WordVec 2 W64) = 457-primOpTag (VecPackOp WordVec 32 W8) = 458-primOpTag (VecPackOp WordVec 16 W16) = 459-primOpTag (VecPackOp WordVec 8 W32) = 460-primOpTag (VecPackOp WordVec 4 W64) = 461-primOpTag (VecPackOp WordVec 64 W8) = 462-primOpTag (VecPackOp WordVec 32 W16) = 463-primOpTag (VecPackOp WordVec 16 W32) = 464-primOpTag (VecPackOp WordVec 8 W64) = 465-primOpTag (VecPackOp FloatVec 4 W32) = 466-primOpTag (VecPackOp FloatVec 2 W64) = 467-primOpTag (VecPackOp FloatVec 8 W32) = 468-primOpTag (VecPackOp FloatVec 4 W64) = 469-primOpTag (VecPackOp FloatVec 16 W32) = 470-primOpTag (VecPackOp FloatVec 8 W64) = 471-primOpTag (VecUnpackOp IntVec 16 W8) = 472-primOpTag (VecUnpackOp IntVec 8 W16) = 473-primOpTag (VecUnpackOp IntVec 4 W32) = 474-primOpTag (VecUnpackOp IntVec 2 W64) = 475-primOpTag (VecUnpackOp IntVec 32 W8) = 476-primOpTag (VecUnpackOp IntVec 16 W16) = 477-primOpTag (VecUnpackOp IntVec 8 W32) = 478-primOpTag (VecUnpackOp IntVec 4 W64) = 479-primOpTag (VecUnpackOp IntVec 64 W8) = 480-primOpTag (VecUnpackOp IntVec 32 W16) = 481-primOpTag (VecUnpackOp IntVec 16 W32) = 482-primOpTag (VecUnpackOp IntVec 8 W64) = 483-primOpTag (VecUnpackOp WordVec 16 W8) = 484-primOpTag (VecUnpackOp WordVec 8 W16) = 485-primOpTag (VecUnpackOp WordVec 4 W32) = 486-primOpTag (VecUnpackOp WordVec 2 W64) = 487-primOpTag (VecUnpackOp WordVec 32 W8) = 488-primOpTag (VecUnpackOp WordVec 16 W16) = 489-primOpTag (VecUnpackOp WordVec 8 W32) = 490-primOpTag (VecUnpackOp WordVec 4 W64) = 491-primOpTag (VecUnpackOp WordVec 64 W8) = 492-primOpTag (VecUnpackOp WordVec 32 W16) = 493-primOpTag (VecUnpackOp WordVec 16 W32) = 494-primOpTag (VecUnpackOp WordVec 8 W64) = 495-primOpTag (VecUnpackOp FloatVec 4 W32) = 496-primOpTag (VecUnpackOp FloatVec 2 W64) = 497-primOpTag (VecUnpackOp FloatVec 8 W32) = 498-primOpTag (VecUnpackOp FloatVec 4 W64) = 499-primOpTag (VecUnpackOp FloatVec 16 W32) = 500-primOpTag (VecUnpackOp FloatVec 8 W64) = 501-primOpTag (VecInsertOp IntVec 16 W8) = 502-primOpTag (VecInsertOp IntVec 8 W16) = 503-primOpTag (VecInsertOp IntVec 4 W32) = 504-primOpTag (VecInsertOp IntVec 2 W64) = 505-primOpTag (VecInsertOp IntVec 32 W8) = 506-primOpTag (VecInsertOp IntVec 16 W16) = 507-primOpTag (VecInsertOp IntVec 8 W32) = 508-primOpTag (VecInsertOp IntVec 4 W64) = 509-primOpTag (VecInsertOp IntVec 64 W8) = 510-primOpTag (VecInsertOp IntVec 32 W16) = 511-primOpTag (VecInsertOp IntVec 16 W32) = 512-primOpTag (VecInsertOp IntVec 8 W64) = 513-primOpTag (VecInsertOp WordVec 16 W8) = 514-primOpTag (VecInsertOp WordVec 8 W16) = 515-primOpTag (VecInsertOp WordVec 4 W32) = 516-primOpTag (VecInsertOp WordVec 2 W64) = 517-primOpTag (VecInsertOp WordVec 32 W8) = 518-primOpTag (VecInsertOp WordVec 16 W16) = 519-primOpTag (VecInsertOp WordVec 8 W32) = 520-primOpTag (VecInsertOp WordVec 4 W64) = 521-primOpTag (VecInsertOp WordVec 64 W8) = 522-primOpTag (VecInsertOp WordVec 32 W16) = 523-primOpTag (VecInsertOp WordVec 16 W32) = 524-primOpTag (VecInsertOp WordVec 8 W64) = 525-primOpTag (VecInsertOp FloatVec 4 W32) = 526-primOpTag (VecInsertOp FloatVec 2 W64) = 527-primOpTag (VecInsertOp FloatVec 8 W32) = 528-primOpTag (VecInsertOp FloatVec 4 W64) = 529-primOpTag (VecInsertOp FloatVec 16 W32) = 530-primOpTag (VecInsertOp FloatVec 8 W64) = 531-primOpTag (VecAddOp IntVec 16 W8) = 532-primOpTag (VecAddOp IntVec 8 W16) = 533-primOpTag (VecAddOp IntVec 4 W32) = 534-primOpTag (VecAddOp IntVec 2 W64) = 535-primOpTag (VecAddOp IntVec 32 W8) = 536-primOpTag (VecAddOp IntVec 16 W16) = 537-primOpTag (VecAddOp IntVec 8 W32) = 538-primOpTag (VecAddOp IntVec 4 W64) = 539-primOpTag (VecAddOp IntVec 64 W8) = 540-primOpTag (VecAddOp IntVec 32 W16) = 541-primOpTag (VecAddOp IntVec 16 W32) = 542-primOpTag (VecAddOp IntVec 8 W64) = 543-primOpTag (VecAddOp WordVec 16 W8) = 544-primOpTag (VecAddOp WordVec 8 W16) = 545-primOpTag (VecAddOp WordVec 4 W32) = 546-primOpTag (VecAddOp WordVec 2 W64) = 547-primOpTag (VecAddOp WordVec 32 W8) = 548-primOpTag (VecAddOp WordVec 16 W16) = 549-primOpTag (VecAddOp WordVec 8 W32) = 550-primOpTag (VecAddOp WordVec 4 W64) = 551-primOpTag (VecAddOp WordVec 64 W8) = 552-primOpTag (VecAddOp WordVec 32 W16) = 553-primOpTag (VecAddOp WordVec 16 W32) = 554-primOpTag (VecAddOp WordVec 8 W64) = 555-primOpTag (VecAddOp FloatVec 4 W32) = 556-primOpTag (VecAddOp FloatVec 2 W64) = 557-primOpTag (VecAddOp FloatVec 8 W32) = 558-primOpTag (VecAddOp FloatVec 4 W64) = 559-primOpTag (VecAddOp FloatVec 16 W32) = 560-primOpTag (VecAddOp FloatVec 8 W64) = 561-primOpTag (VecSubOp IntVec 16 W8) = 562-primOpTag (VecSubOp IntVec 8 W16) = 563-primOpTag (VecSubOp IntVec 4 W32) = 564-primOpTag (VecSubOp IntVec 2 W64) = 565-primOpTag (VecSubOp IntVec 32 W8) = 566-primOpTag (VecSubOp IntVec 16 W16) = 567-primOpTag (VecSubOp IntVec 8 W32) = 568-primOpTag (VecSubOp IntVec 4 W64) = 569-primOpTag (VecSubOp IntVec 64 W8) = 570-primOpTag (VecSubOp IntVec 32 W16) = 571-primOpTag (VecSubOp IntVec 16 W32) = 572-primOpTag (VecSubOp IntVec 8 W64) = 573-primOpTag (VecSubOp WordVec 16 W8) = 574-primOpTag (VecSubOp WordVec 8 W16) = 575-primOpTag (VecSubOp WordVec 4 W32) = 576-primOpTag (VecSubOp WordVec 2 W64) = 577-primOpTag (VecSubOp WordVec 32 W8) = 578-primOpTag (VecSubOp WordVec 16 W16) = 579-primOpTag (VecSubOp WordVec 8 W32) = 580-primOpTag (VecSubOp WordVec 4 W64) = 581-primOpTag (VecSubOp WordVec 64 W8) = 582-primOpTag (VecSubOp WordVec 32 W16) = 583-primOpTag (VecSubOp WordVec 16 W32) = 584-primOpTag (VecSubOp WordVec 8 W64) = 585-primOpTag (VecSubOp FloatVec 4 W32) = 586-primOpTag (VecSubOp FloatVec 2 W64) = 587-primOpTag (VecSubOp FloatVec 8 W32) = 588-primOpTag (VecSubOp FloatVec 4 W64) = 589-primOpTag (VecSubOp FloatVec 16 W32) = 590-primOpTag (VecSubOp FloatVec 8 W64) = 591-primOpTag (VecMulOp IntVec 16 W8) = 592-primOpTag (VecMulOp IntVec 8 W16) = 593-primOpTag (VecMulOp IntVec 4 W32) = 594-primOpTag (VecMulOp IntVec 2 W64) = 595-primOpTag (VecMulOp IntVec 32 W8) = 596-primOpTag (VecMulOp IntVec 16 W16) = 597-primOpTag (VecMulOp IntVec 8 W32) = 598-primOpTag (VecMulOp IntVec 4 W64) = 599-primOpTag (VecMulOp IntVec 64 W8) = 600-primOpTag (VecMulOp IntVec 32 W16) = 601-primOpTag (VecMulOp IntVec 16 W32) = 602-primOpTag (VecMulOp IntVec 8 W64) = 603-primOpTag (VecMulOp WordVec 16 W8) = 604-primOpTag (VecMulOp WordVec 8 W16) = 605-primOpTag (VecMulOp WordVec 4 W32) = 606-primOpTag (VecMulOp WordVec 2 W64) = 607-primOpTag (VecMulOp WordVec 32 W8) = 608-primOpTag (VecMulOp WordVec 16 W16) = 609-primOpTag (VecMulOp WordVec 8 W32) = 610-primOpTag (VecMulOp WordVec 4 W64) = 611-primOpTag (VecMulOp WordVec 64 W8) = 612-primOpTag (VecMulOp WordVec 32 W16) = 613-primOpTag (VecMulOp WordVec 16 W32) = 614-primOpTag (VecMulOp WordVec 8 W64) = 615-primOpTag (VecMulOp FloatVec 4 W32) = 616-primOpTag (VecMulOp FloatVec 2 W64) = 617-primOpTag (VecMulOp FloatVec 8 W32) = 618-primOpTag (VecMulOp FloatVec 4 W64) = 619-primOpTag (VecMulOp FloatVec 16 W32) = 620-primOpTag (VecMulOp FloatVec 8 W64) = 621-primOpTag (VecDivOp FloatVec 4 W32) = 622-primOpTag (VecDivOp FloatVec 2 W64) = 623-primOpTag (VecDivOp FloatVec 8 W32) = 624-primOpTag (VecDivOp FloatVec 4 W64) = 625-primOpTag (VecDivOp FloatVec 16 W32) = 626-primOpTag (VecDivOp FloatVec 8 W64) = 627-primOpTag (VecQuotOp IntVec 16 W8) = 628-primOpTag (VecQuotOp IntVec 8 W16) = 629-primOpTag (VecQuotOp IntVec 4 W32) = 630-primOpTag (VecQuotOp IntVec 2 W64) = 631-primOpTag (VecQuotOp IntVec 32 W8) = 632-primOpTag (VecQuotOp IntVec 16 W16) = 633-primOpTag (VecQuotOp IntVec 8 W32) = 634-primOpTag (VecQuotOp IntVec 4 W64) = 635-primOpTag (VecQuotOp IntVec 64 W8) = 636-primOpTag (VecQuotOp IntVec 32 W16) = 637-primOpTag (VecQuotOp IntVec 16 W32) = 638-primOpTag (VecQuotOp IntVec 8 W64) = 639-primOpTag (VecQuotOp WordVec 16 W8) = 640-primOpTag (VecQuotOp WordVec 8 W16) = 641-primOpTag (VecQuotOp WordVec 4 W32) = 642-primOpTag (VecQuotOp WordVec 2 W64) = 643-primOpTag (VecQuotOp WordVec 32 W8) = 644-primOpTag (VecQuotOp WordVec 16 W16) = 645-primOpTag (VecQuotOp WordVec 8 W32) = 646-primOpTag (VecQuotOp WordVec 4 W64) = 647-primOpTag (VecQuotOp WordVec 64 W8) = 648-primOpTag (VecQuotOp WordVec 32 W16) = 649-primOpTag (VecQuotOp WordVec 16 W32) = 650-primOpTag (VecQuotOp WordVec 8 W64) = 651-primOpTag (VecRemOp IntVec 16 W8) = 652-primOpTag (VecRemOp IntVec 8 W16) = 653-primOpTag (VecRemOp IntVec 4 W32) = 654-primOpTag (VecRemOp IntVec 2 W64) = 655-primOpTag (VecRemOp IntVec 32 W8) = 656-primOpTag (VecRemOp IntVec 16 W16) = 657-primOpTag (VecRemOp IntVec 8 W32) = 658-primOpTag (VecRemOp IntVec 4 W64) = 659-primOpTag (VecRemOp IntVec 64 W8) = 660-primOpTag (VecRemOp IntVec 32 W16) = 661-primOpTag (VecRemOp IntVec 16 W32) = 662-primOpTag (VecRemOp IntVec 8 W64) = 663-primOpTag (VecRemOp WordVec 16 W8) = 664-primOpTag (VecRemOp WordVec 8 W16) = 665-primOpTag (VecRemOp WordVec 4 W32) = 666-primOpTag (VecRemOp WordVec 2 W64) = 667-primOpTag (VecRemOp WordVec 32 W8) = 668-primOpTag (VecRemOp WordVec 16 W16) = 669-primOpTag (VecRemOp WordVec 8 W32) = 670-primOpTag (VecRemOp WordVec 4 W64) = 671-primOpTag (VecRemOp WordVec 64 W8) = 672-primOpTag (VecRemOp WordVec 32 W16) = 673-primOpTag (VecRemOp WordVec 16 W32) = 674-primOpTag (VecRemOp WordVec 8 W64) = 675-primOpTag (VecNegOp IntVec 16 W8) = 676-primOpTag (VecNegOp IntVec 8 W16) = 677-primOpTag (VecNegOp IntVec 4 W32) = 678-primOpTag (VecNegOp IntVec 2 W64) = 679-primOpTag (VecNegOp IntVec 32 W8) = 680-primOpTag (VecNegOp IntVec 16 W16) = 681-primOpTag (VecNegOp IntVec 8 W32) = 682-primOpTag (VecNegOp IntVec 4 W64) = 683-primOpTag (VecNegOp IntVec 64 W8) = 684-primOpTag (VecNegOp IntVec 32 W16) = 685-primOpTag (VecNegOp IntVec 16 W32) = 686-primOpTag (VecNegOp IntVec 8 W64) = 687-primOpTag (VecNegOp FloatVec 4 W32) = 688-primOpTag (VecNegOp FloatVec 2 W64) = 689-primOpTag (VecNegOp FloatVec 8 W32) = 690-primOpTag (VecNegOp FloatVec 4 W64) = 691-primOpTag (VecNegOp FloatVec 16 W32) = 692-primOpTag (VecNegOp FloatVec 8 W64) = 693-primOpTag (VecIndexByteArrayOp IntVec 16 W8) = 694-primOpTag (VecIndexByteArrayOp IntVec 8 W16) = 695-primOpTag (VecIndexByteArrayOp IntVec 4 W32) = 696-primOpTag (VecIndexByteArrayOp IntVec 2 W64) = 697-primOpTag (VecIndexByteArrayOp IntVec 32 W8) = 698-primOpTag (VecIndexByteArrayOp IntVec 16 W16) = 699-primOpTag (VecIndexByteArrayOp IntVec 8 W32) = 700-primOpTag (VecIndexByteArrayOp IntVec 4 W64) = 701-primOpTag (VecIndexByteArrayOp IntVec 64 W8) = 702-primOpTag (VecIndexByteArrayOp IntVec 32 W16) = 703-primOpTag (VecIndexByteArrayOp IntVec 16 W32) = 704-primOpTag (VecIndexByteArrayOp IntVec 8 W64) = 705-primOpTag (VecIndexByteArrayOp WordVec 16 W8) = 706-primOpTag (VecIndexByteArrayOp WordVec 8 W16) = 707-primOpTag (VecIndexByteArrayOp WordVec 4 W32) = 708-primOpTag (VecIndexByteArrayOp WordVec 2 W64) = 709-primOpTag (VecIndexByteArrayOp WordVec 32 W8) = 710-primOpTag (VecIndexByteArrayOp WordVec 16 W16) = 711-primOpTag (VecIndexByteArrayOp WordVec 8 W32) = 712-primOpTag (VecIndexByteArrayOp WordVec 4 W64) = 713-primOpTag (VecIndexByteArrayOp WordVec 64 W8) = 714-primOpTag (VecIndexByteArrayOp WordVec 32 W16) = 715-primOpTag (VecIndexByteArrayOp WordVec 16 W32) = 716-primOpTag (VecIndexByteArrayOp WordVec 8 W64) = 717-primOpTag (VecIndexByteArrayOp FloatVec 4 W32) = 718-primOpTag (VecIndexByteArrayOp FloatVec 2 W64) = 719-primOpTag (VecIndexByteArrayOp FloatVec 8 W32) = 720-primOpTag (VecIndexByteArrayOp FloatVec 4 W64) = 721-primOpTag (VecIndexByteArrayOp FloatVec 16 W32) = 722-primOpTag (VecIndexByteArrayOp FloatVec 8 W64) = 723-primOpTag (VecReadByteArrayOp IntVec 16 W8) = 724-primOpTag (VecReadByteArrayOp IntVec 8 W16) = 725-primOpTag (VecReadByteArrayOp IntVec 4 W32) = 726-primOpTag (VecReadByteArrayOp IntVec 2 W64) = 727-primOpTag (VecReadByteArrayOp IntVec 32 W8) = 728-primOpTag (VecReadByteArrayOp IntVec 16 W16) = 729-primOpTag (VecReadByteArrayOp IntVec 8 W32) = 730-primOpTag (VecReadByteArrayOp IntVec 4 W64) = 731-primOpTag (VecReadByteArrayOp IntVec 64 W8) = 732-primOpTag (VecReadByteArrayOp IntVec 32 W16) = 733-primOpTag (VecReadByteArrayOp IntVec 16 W32) = 734-primOpTag (VecReadByteArrayOp IntVec 8 W64) = 735-primOpTag (VecReadByteArrayOp WordVec 16 W8) = 736-primOpTag (VecReadByteArrayOp WordVec 8 W16) = 737-primOpTag (VecReadByteArrayOp WordVec 4 W32) = 738-primOpTag (VecReadByteArrayOp WordVec 2 W64) = 739-primOpTag (VecReadByteArrayOp WordVec 32 W8) = 740-primOpTag (VecReadByteArrayOp WordVec 16 W16) = 741-primOpTag (VecReadByteArrayOp WordVec 8 W32) = 742-primOpTag (VecReadByteArrayOp WordVec 4 W64) = 743-primOpTag (VecReadByteArrayOp WordVec 64 W8) = 744-primOpTag (VecReadByteArrayOp WordVec 32 W16) = 745-primOpTag (VecReadByteArrayOp WordVec 16 W32) = 746-primOpTag (VecReadByteArrayOp WordVec 8 W64) = 747-primOpTag (VecReadByteArrayOp FloatVec 4 W32) = 748-primOpTag (VecReadByteArrayOp FloatVec 2 W64) = 749-primOpTag (VecReadByteArrayOp FloatVec 8 W32) = 750-primOpTag (VecReadByteArrayOp FloatVec 4 W64) = 751-primOpTag (VecReadByteArrayOp FloatVec 16 W32) = 752-primOpTag (VecReadByteArrayOp FloatVec 8 W64) = 753-primOpTag (VecWriteByteArrayOp IntVec 16 W8) = 754-primOpTag (VecWriteByteArrayOp IntVec 8 W16) = 755-primOpTag (VecWriteByteArrayOp IntVec 4 W32) = 756-primOpTag (VecWriteByteArrayOp IntVec 2 W64) = 757-primOpTag (VecWriteByteArrayOp IntVec 32 W8) = 758-primOpTag (VecWriteByteArrayOp IntVec 16 W16) = 759-primOpTag (VecWriteByteArrayOp IntVec 8 W32) = 760-primOpTag (VecWriteByteArrayOp IntVec 4 W64) = 761-primOpTag (VecWriteByteArrayOp IntVec 64 W8) = 762-primOpTag (VecWriteByteArrayOp IntVec 32 W16) = 763-primOpTag (VecWriteByteArrayOp IntVec 16 W32) = 764-primOpTag (VecWriteByteArrayOp IntVec 8 W64) = 765-primOpTag (VecWriteByteArrayOp WordVec 16 W8) = 766-primOpTag (VecWriteByteArrayOp WordVec 8 W16) = 767-primOpTag (VecWriteByteArrayOp WordVec 4 W32) = 768-primOpTag (VecWriteByteArrayOp WordVec 2 W64) = 769-primOpTag (VecWriteByteArrayOp WordVec 32 W8) = 770-primOpTag (VecWriteByteArrayOp WordVec 16 W16) = 771-primOpTag (VecWriteByteArrayOp WordVec 8 W32) = 772-primOpTag (VecWriteByteArrayOp WordVec 4 W64) = 773-primOpTag (VecWriteByteArrayOp WordVec 64 W8) = 774-primOpTag (VecWriteByteArrayOp WordVec 32 W16) = 775-primOpTag (VecWriteByteArrayOp WordVec 16 W32) = 776-primOpTag (VecWriteByteArrayOp WordVec 8 W64) = 777-primOpTag (VecWriteByteArrayOp FloatVec 4 W32) = 778-primOpTag (VecWriteByteArrayOp FloatVec 2 W64) = 779-primOpTag (VecWriteByteArrayOp FloatVec 8 W32) = 780-primOpTag (VecWriteByteArrayOp FloatVec 4 W64) = 781-primOpTag (VecWriteByteArrayOp FloatVec 16 W32) = 782-primOpTag (VecWriteByteArrayOp FloatVec 8 W64) = 783-primOpTag (VecIndexOffAddrOp IntVec 16 W8) = 784-primOpTag (VecIndexOffAddrOp IntVec 8 W16) = 785-primOpTag (VecIndexOffAddrOp IntVec 4 W32) = 786-primOpTag (VecIndexOffAddrOp IntVec 2 W64) = 787-primOpTag (VecIndexOffAddrOp IntVec 32 W8) = 788-primOpTag (VecIndexOffAddrOp IntVec 16 W16) = 789-primOpTag (VecIndexOffAddrOp IntVec 8 W32) = 790-primOpTag (VecIndexOffAddrOp IntVec 4 W64) = 791-primOpTag (VecIndexOffAddrOp IntVec 64 W8) = 792-primOpTag (VecIndexOffAddrOp IntVec 32 W16) = 793-primOpTag (VecIndexOffAddrOp IntVec 16 W32) = 794-primOpTag (VecIndexOffAddrOp IntVec 8 W64) = 795-primOpTag (VecIndexOffAddrOp WordVec 16 W8) = 796-primOpTag (VecIndexOffAddrOp WordVec 8 W16) = 797-primOpTag (VecIndexOffAddrOp WordVec 4 W32) = 798-primOpTag (VecIndexOffAddrOp WordVec 2 W64) = 799-primOpTag (VecIndexOffAddrOp WordVec 32 W8) = 800-primOpTag (VecIndexOffAddrOp WordVec 16 W16) = 801-primOpTag (VecIndexOffAddrOp WordVec 8 W32) = 802-primOpTag (VecIndexOffAddrOp WordVec 4 W64) = 803-primOpTag (VecIndexOffAddrOp WordVec 64 W8) = 804-primOpTag (VecIndexOffAddrOp WordVec 32 W16) = 805-primOpTag (VecIndexOffAddrOp WordVec 16 W32) = 806-primOpTag (VecIndexOffAddrOp WordVec 8 W64) = 807-primOpTag (VecIndexOffAddrOp FloatVec 4 W32) = 808-primOpTag (VecIndexOffAddrOp FloatVec 2 W64) = 809-primOpTag (VecIndexOffAddrOp FloatVec 8 W32) = 810-primOpTag (VecIndexOffAddrOp FloatVec 4 W64) = 811-primOpTag (VecIndexOffAddrOp FloatVec 16 W32) = 812-primOpTag (VecIndexOffAddrOp FloatVec 8 W64) = 813-primOpTag (VecReadOffAddrOp IntVec 16 W8) = 814-primOpTag (VecReadOffAddrOp IntVec 8 W16) = 815-primOpTag (VecReadOffAddrOp IntVec 4 W32) = 816-primOpTag (VecReadOffAddrOp IntVec 2 W64) = 817-primOpTag (VecReadOffAddrOp IntVec 32 W8) = 818-primOpTag (VecReadOffAddrOp IntVec 16 W16) = 819-primOpTag (VecReadOffAddrOp IntVec 8 W32) = 820-primOpTag (VecReadOffAddrOp IntVec 4 W64) = 821-primOpTag (VecReadOffAddrOp IntVec 64 W8) = 822-primOpTag (VecReadOffAddrOp IntVec 32 W16) = 823-primOpTag (VecReadOffAddrOp IntVec 16 W32) = 824-primOpTag (VecReadOffAddrOp IntVec 8 W64) = 825-primOpTag (VecReadOffAddrOp WordVec 16 W8) = 826-primOpTag (VecReadOffAddrOp WordVec 8 W16) = 827-primOpTag (VecReadOffAddrOp WordVec 4 W32) = 828-primOpTag (VecReadOffAddrOp WordVec 2 W64) = 829-primOpTag (VecReadOffAddrOp WordVec 32 W8) = 830-primOpTag (VecReadOffAddrOp WordVec 16 W16) = 831-primOpTag (VecReadOffAddrOp WordVec 8 W32) = 832-primOpTag (VecReadOffAddrOp WordVec 4 W64) = 833-primOpTag (VecReadOffAddrOp WordVec 64 W8) = 834-primOpTag (VecReadOffAddrOp WordVec 32 W16) = 835-primOpTag (VecReadOffAddrOp WordVec 16 W32) = 836-primOpTag (VecReadOffAddrOp WordVec 8 W64) = 837-primOpTag (VecReadOffAddrOp FloatVec 4 W32) = 838-primOpTag (VecReadOffAddrOp FloatVec 2 W64) = 839-primOpTag (VecReadOffAddrOp FloatVec 8 W32) = 840-primOpTag (VecReadOffAddrOp FloatVec 4 W64) = 841-primOpTag (VecReadOffAddrOp FloatVec 16 W32) = 842-primOpTag (VecReadOffAddrOp FloatVec 8 W64) = 843-primOpTag (VecWriteOffAddrOp IntVec 16 W8) = 844-primOpTag (VecWriteOffAddrOp IntVec 8 W16) = 845-primOpTag (VecWriteOffAddrOp IntVec 4 W32) = 846-primOpTag (VecWriteOffAddrOp IntVec 2 W64) = 847-primOpTag (VecWriteOffAddrOp IntVec 32 W8) = 848-primOpTag (VecWriteOffAddrOp IntVec 16 W16) = 849-primOpTag (VecWriteOffAddrOp IntVec 8 W32) = 850-primOpTag (VecWriteOffAddrOp IntVec 4 W64) = 851-primOpTag (VecWriteOffAddrOp IntVec 64 W8) = 852-primOpTag (VecWriteOffAddrOp IntVec 32 W16) = 853-primOpTag (VecWriteOffAddrOp IntVec 16 W32) = 854-primOpTag (VecWriteOffAddrOp IntVec 8 W64) = 855-primOpTag (VecWriteOffAddrOp WordVec 16 W8) = 856-primOpTag (VecWriteOffAddrOp WordVec 8 W16) = 857-primOpTag (VecWriteOffAddrOp WordVec 4 W32) = 858-primOpTag (VecWriteOffAddrOp WordVec 2 W64) = 859-primOpTag (VecWriteOffAddrOp WordVec 32 W8) = 860-primOpTag (VecWriteOffAddrOp WordVec 16 W16) = 861-primOpTag (VecWriteOffAddrOp WordVec 8 W32) = 862-primOpTag (VecWriteOffAddrOp WordVec 4 W64) = 863-primOpTag (VecWriteOffAddrOp WordVec 64 W8) = 864-primOpTag (VecWriteOffAddrOp WordVec 32 W16) = 865-primOpTag (VecWriteOffAddrOp WordVec 16 W32) = 866-primOpTag (VecWriteOffAddrOp WordVec 8 W64) = 867-primOpTag (VecWriteOffAddrOp FloatVec 4 W32) = 868-primOpTag (VecWriteOffAddrOp FloatVec 2 W64) = 869-primOpTag (VecWriteOffAddrOp FloatVec 8 W32) = 870-primOpTag (VecWriteOffAddrOp FloatVec 4 W64) = 871-primOpTag (VecWriteOffAddrOp FloatVec 16 W32) = 872-primOpTag (VecWriteOffAddrOp FloatVec 8 W64) = 873-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W8) = 874-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W16) = 875-primOpTag (VecIndexScalarByteArrayOp IntVec 4 W32) = 876-primOpTag (VecIndexScalarByteArrayOp IntVec 2 W64) = 877-primOpTag (VecIndexScalarByteArrayOp IntVec 32 W8) = 878-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W16) = 879-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W32) = 880-primOpTag (VecIndexScalarByteArrayOp IntVec 4 W64) = 881-primOpTag (VecIndexScalarByteArrayOp IntVec 64 W8) = 882-primOpTag (VecIndexScalarByteArrayOp IntVec 32 W16) = 883-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W32) = 884-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W64) = 885-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W8) = 886-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W16) = 887-primOpTag (VecIndexScalarByteArrayOp WordVec 4 W32) = 888-primOpTag (VecIndexScalarByteArrayOp WordVec 2 W64) = 889-primOpTag (VecIndexScalarByteArrayOp WordVec 32 W8) = 890-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W16) = 891-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W32) = 892-primOpTag (VecIndexScalarByteArrayOp WordVec 4 W64) = 893-primOpTag (VecIndexScalarByteArrayOp WordVec 64 W8) = 894-primOpTag (VecIndexScalarByteArrayOp WordVec 32 W16) = 895-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W32) = 896-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W64) = 897-primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W32) = 898-primOpTag (VecIndexScalarByteArrayOp FloatVec 2 W64) = 899-primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W32) = 900-primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W64) = 901-primOpTag (VecIndexScalarByteArrayOp FloatVec 16 W32) = 902-primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W64) = 903-primOpTag (VecReadScalarByteArrayOp IntVec 16 W8) = 904-primOpTag (VecReadScalarByteArrayOp IntVec 8 W16) = 905-primOpTag (VecReadScalarByteArrayOp IntVec 4 W32) = 906-primOpTag (VecReadScalarByteArrayOp IntVec 2 W64) = 907-primOpTag (VecReadScalarByteArrayOp IntVec 32 W8) = 908-primOpTag (VecReadScalarByteArrayOp IntVec 16 W16) = 909-primOpTag (VecReadScalarByteArrayOp IntVec 8 W32) = 910-primOpTag (VecReadScalarByteArrayOp IntVec 4 W64) = 911-primOpTag (VecReadScalarByteArrayOp IntVec 64 W8) = 912-primOpTag (VecReadScalarByteArrayOp IntVec 32 W16) = 913-primOpTag (VecReadScalarByteArrayOp IntVec 16 W32) = 914-primOpTag (VecReadScalarByteArrayOp IntVec 8 W64) = 915-primOpTag (VecReadScalarByteArrayOp WordVec 16 W8) = 916-primOpTag (VecReadScalarByteArrayOp WordVec 8 W16) = 917-primOpTag (VecReadScalarByteArrayOp WordVec 4 W32) = 918-primOpTag (VecReadScalarByteArrayOp WordVec 2 W64) = 919-primOpTag (VecReadScalarByteArrayOp WordVec 32 W8) = 920-primOpTag (VecReadScalarByteArrayOp WordVec 16 W16) = 921-primOpTag (VecReadScalarByteArrayOp WordVec 8 W32) = 922-primOpTag (VecReadScalarByteArrayOp WordVec 4 W64) = 923-primOpTag (VecReadScalarByteArrayOp WordVec 64 W8) = 924-primOpTag (VecReadScalarByteArrayOp WordVec 32 W16) = 925-primOpTag (VecReadScalarByteArrayOp WordVec 16 W32) = 926-primOpTag (VecReadScalarByteArrayOp WordVec 8 W64) = 927-primOpTag (VecReadScalarByteArrayOp FloatVec 4 W32) = 928-primOpTag (VecReadScalarByteArrayOp FloatVec 2 W64) = 929-primOpTag (VecReadScalarByteArrayOp FloatVec 8 W32) = 930-primOpTag (VecReadScalarByteArrayOp FloatVec 4 W64) = 931-primOpTag (VecReadScalarByteArrayOp FloatVec 16 W32) = 932-primOpTag (VecReadScalarByteArrayOp FloatVec 8 W64) = 933-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W8) = 934-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W16) = 935-primOpTag (VecWriteScalarByteArrayOp IntVec 4 W32) = 936-primOpTag (VecWriteScalarByteArrayOp IntVec 2 W64) = 937-primOpTag (VecWriteScalarByteArrayOp IntVec 32 W8) = 938-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W16) = 939-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W32) = 940-primOpTag (VecWriteScalarByteArrayOp IntVec 4 W64) = 941-primOpTag (VecWriteScalarByteArrayOp IntVec 64 W8) = 942-primOpTag (VecWriteScalarByteArrayOp IntVec 32 W16) = 943-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W32) = 944-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W64) = 945-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W8) = 946-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W16) = 947-primOpTag (VecWriteScalarByteArrayOp WordVec 4 W32) = 948-primOpTag (VecWriteScalarByteArrayOp WordVec 2 W64) = 949-primOpTag (VecWriteScalarByteArrayOp WordVec 32 W8) = 950-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W16) = 951-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W32) = 952-primOpTag (VecWriteScalarByteArrayOp WordVec 4 W64) = 953-primOpTag (VecWriteScalarByteArrayOp WordVec 64 W8) = 954-primOpTag (VecWriteScalarByteArrayOp WordVec 32 W16) = 955-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W32) = 956-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W64) = 957-primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W32) = 958-primOpTag (VecWriteScalarByteArrayOp FloatVec 2 W64) = 959-primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W32) = 960-primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W64) = 961-primOpTag (VecWriteScalarByteArrayOp FloatVec 16 W32) = 962-primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W64) = 963-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W8) = 964-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W16) = 965-primOpTag (VecIndexScalarOffAddrOp IntVec 4 W32) = 966-primOpTag (VecIndexScalarOffAddrOp IntVec 2 W64) = 967-primOpTag (VecIndexScalarOffAddrOp IntVec 32 W8) = 968-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W16) = 969-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W32) = 970-primOpTag (VecIndexScalarOffAddrOp IntVec 4 W64) = 971-primOpTag (VecIndexScalarOffAddrOp IntVec 64 W8) = 972-primOpTag (VecIndexScalarOffAddrOp IntVec 32 W16) = 973-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W32) = 974-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W64) = 975-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W8) = 976-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W16) = 977-primOpTag (VecIndexScalarOffAddrOp WordVec 4 W32) = 978-primOpTag (VecIndexScalarOffAddrOp WordVec 2 W64) = 979-primOpTag (VecIndexScalarOffAddrOp WordVec 32 W8) = 980-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W16) = 981-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W32) = 982-primOpTag (VecIndexScalarOffAddrOp WordVec 4 W64) = 983-primOpTag (VecIndexScalarOffAddrOp WordVec 64 W8) = 984-primOpTag (VecIndexScalarOffAddrOp WordVec 32 W16) = 985-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W32) = 986-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W64) = 987-primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W32) = 988-primOpTag (VecIndexScalarOffAddrOp FloatVec 2 W64) = 989-primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W32) = 990-primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W64) = 991-primOpTag (VecIndexScalarOffAddrOp FloatVec 16 W32) = 992-primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W64) = 993-primOpTag (VecReadScalarOffAddrOp IntVec 16 W8) = 994-primOpTag (VecReadScalarOffAddrOp IntVec 8 W16) = 995-primOpTag (VecReadScalarOffAddrOp IntVec 4 W32) = 996-primOpTag (VecReadScalarOffAddrOp IntVec 2 W64) = 997-primOpTag (VecReadScalarOffAddrOp IntVec 32 W8) = 998-primOpTag (VecReadScalarOffAddrOp IntVec 16 W16) = 999-primOpTag (VecReadScalarOffAddrOp IntVec 8 W32) = 1000-primOpTag (VecReadScalarOffAddrOp IntVec 4 W64) = 1001-primOpTag (VecReadScalarOffAddrOp IntVec 64 W8) = 1002-primOpTag (VecReadScalarOffAddrOp IntVec 32 W16) = 1003-primOpTag (VecReadScalarOffAddrOp IntVec 16 W32) = 1004-primOpTag (VecReadScalarOffAddrOp IntVec 8 W64) = 1005-primOpTag (VecReadScalarOffAddrOp WordVec 16 W8) = 1006-primOpTag (VecReadScalarOffAddrOp WordVec 8 W16) = 1007-primOpTag (VecReadScalarOffAddrOp WordVec 4 W32) = 1008-primOpTag (VecReadScalarOffAddrOp WordVec 2 W64) = 1009-primOpTag (VecReadScalarOffAddrOp WordVec 32 W8) = 1010-primOpTag (VecReadScalarOffAddrOp WordVec 16 W16) = 1011-primOpTag (VecReadScalarOffAddrOp WordVec 8 W32) = 1012-primOpTag (VecReadScalarOffAddrOp WordVec 4 W64) = 1013-primOpTag (VecReadScalarOffAddrOp WordVec 64 W8) = 1014-primOpTag (VecReadScalarOffAddrOp WordVec 32 W16) = 1015-primOpTag (VecReadScalarOffAddrOp WordVec 16 W32) = 1016-primOpTag (VecReadScalarOffAddrOp WordVec 8 W64) = 1017-primOpTag (VecReadScalarOffAddrOp FloatVec 4 W32) = 1018-primOpTag (VecReadScalarOffAddrOp FloatVec 2 W64) = 1019-primOpTag (VecReadScalarOffAddrOp FloatVec 8 W32) = 1020-primOpTag (VecReadScalarOffAddrOp FloatVec 4 W64) = 1021-primOpTag (VecReadScalarOffAddrOp FloatVec 16 W32) = 1022-primOpTag (VecReadScalarOffAddrOp FloatVec 8 W64) = 1023-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W8) = 1024-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W16) = 1025-primOpTag (VecWriteScalarOffAddrOp IntVec 4 W32) = 1026-primOpTag (VecWriteScalarOffAddrOp IntVec 2 W64) = 1027-primOpTag (VecWriteScalarOffAddrOp IntVec 32 W8) = 1028-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W16) = 1029-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W32) = 1030-primOpTag (VecWriteScalarOffAddrOp IntVec 4 W64) = 1031-primOpTag (VecWriteScalarOffAddrOp IntVec 64 W8) = 1032-primOpTag (VecWriteScalarOffAddrOp IntVec 32 W16) = 1033-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W32) = 1034-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W64) = 1035-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W8) = 1036-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W16) = 1037-primOpTag (VecWriteScalarOffAddrOp WordVec 4 W32) = 1038-primOpTag (VecWriteScalarOffAddrOp WordVec 2 W64) = 1039-primOpTag (VecWriteScalarOffAddrOp WordVec 32 W8) = 1040-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W16) = 1041-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W32) = 1042-primOpTag (VecWriteScalarOffAddrOp WordVec 4 W64) = 1043-primOpTag (VecWriteScalarOffAddrOp WordVec 64 W8) = 1044-primOpTag (VecWriteScalarOffAddrOp WordVec 32 W16) = 1045-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W32) = 1046-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W64) = 1047-primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W32) = 1048-primOpTag (VecWriteScalarOffAddrOp FloatVec 2 W64) = 1049-primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W32) = 1050-primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W64) = 1051-primOpTag (VecWriteScalarOffAddrOp FloatVec 16 W32) = 1052-primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W64) = 1053-primOpTag PrefetchByteArrayOp3 = 1054-primOpTag PrefetchMutableByteArrayOp3 = 1055-primOpTag PrefetchAddrOp3 = 1056-primOpTag PrefetchValueOp3 = 1057-primOpTag PrefetchByteArrayOp2 = 1058-primOpTag PrefetchMutableByteArrayOp2 = 1059-primOpTag PrefetchAddrOp2 = 1060-primOpTag PrefetchValueOp2 = 1061-primOpTag PrefetchByteArrayOp1 = 1062-primOpTag PrefetchMutableByteArrayOp1 = 1063-primOpTag PrefetchAddrOp1 = 1064-primOpTag PrefetchValueOp1 = 1065-primOpTag PrefetchByteArrayOp0 = 1066-primOpTag PrefetchMutableByteArrayOp0 = 1067-primOpTag PrefetchAddrOp0 = 1068-primOpTag PrefetchValueOp0 = 1069+maxPrimOpTag = 1080+primOpTag :: PrimOp -> Int+primOpTag CharGtOp = 1+primOpTag CharGeOp = 2+primOpTag CharEqOp = 3+primOpTag CharNeOp = 4+primOpTag CharLtOp = 5+primOpTag CharLeOp = 6+primOpTag OrdOp = 7+primOpTag IntAddOp = 8+primOpTag IntSubOp = 9+primOpTag IntMulOp = 10+primOpTag IntMulMayOfloOp = 11+primOpTag IntQuotOp = 12+primOpTag IntRemOp = 13+primOpTag IntQuotRemOp = 14+primOpTag AndIOp = 15+primOpTag OrIOp = 16+primOpTag XorIOp = 17+primOpTag NotIOp = 18+primOpTag IntNegOp = 19+primOpTag IntAddCOp = 20+primOpTag IntSubCOp = 21+primOpTag IntGtOp = 22+primOpTag IntGeOp = 23+primOpTag IntEqOp = 24+primOpTag IntNeOp = 25+primOpTag IntLtOp = 26+primOpTag IntLeOp = 27+primOpTag ChrOp = 28+primOpTag Int2WordOp = 29+primOpTag Int2FloatOp = 30+primOpTag Int2DoubleOp = 31+primOpTag Word2FloatOp = 32+primOpTag Word2DoubleOp = 33+primOpTag ISllOp = 34+primOpTag ISraOp = 35+primOpTag ISrlOp = 36+primOpTag WordAddOp = 37+primOpTag WordSubCOp = 38+primOpTag WordAdd2Op = 39+primOpTag WordSubOp = 40+primOpTag WordMulOp = 41+primOpTag WordMul2Op = 42+primOpTag WordQuotOp = 43+primOpTag WordRemOp = 44+primOpTag WordQuotRemOp = 45+primOpTag WordQuotRem2Op = 46+primOpTag AndOp = 47+primOpTag OrOp = 48+primOpTag XorOp = 49+primOpTag NotOp = 50+primOpTag SllOp = 51+primOpTag SrlOp = 52+primOpTag Word2IntOp = 53+primOpTag WordGtOp = 54+primOpTag WordGeOp = 55+primOpTag WordEqOp = 56+primOpTag WordNeOp = 57+primOpTag WordLtOp = 58+primOpTag WordLeOp = 59+primOpTag PopCnt8Op = 60+primOpTag PopCnt16Op = 61+primOpTag PopCnt32Op = 62+primOpTag PopCnt64Op = 63+primOpTag PopCntOp = 64+primOpTag Pdep8Op = 65+primOpTag Pdep16Op = 66+primOpTag Pdep32Op = 67+primOpTag Pdep64Op = 68+primOpTag PdepOp = 69+primOpTag Pext8Op = 70+primOpTag Pext16Op = 71+primOpTag Pext32Op = 72+primOpTag Pext64Op = 73+primOpTag PextOp = 74+primOpTag Clz8Op = 75+primOpTag Clz16Op = 76+primOpTag Clz32Op = 77+primOpTag Clz64Op = 78+primOpTag ClzOp = 79+primOpTag Ctz8Op = 80+primOpTag Ctz16Op = 81+primOpTag Ctz32Op = 82+primOpTag Ctz64Op = 83+primOpTag CtzOp = 84+primOpTag BSwap16Op = 85+primOpTag BSwap32Op = 86+primOpTag BSwap64Op = 87+primOpTag BSwapOp = 88+primOpTag Narrow8IntOp = 89+primOpTag Narrow16IntOp = 90+primOpTag Narrow32IntOp = 91+primOpTag Narrow8WordOp = 92+primOpTag Narrow16WordOp = 93+primOpTag Narrow32WordOp = 94+primOpTag DoubleGtOp = 95+primOpTag DoubleGeOp = 96+primOpTag DoubleEqOp = 97+primOpTag DoubleNeOp = 98+primOpTag DoubleLtOp = 99+primOpTag DoubleLeOp = 100+primOpTag DoubleAddOp = 101+primOpTag DoubleSubOp = 102+primOpTag DoubleMulOp = 103+primOpTag DoubleDivOp = 104+primOpTag DoubleNegOp = 105+primOpTag DoubleFabsOp = 106+primOpTag Double2IntOp = 107+primOpTag Double2FloatOp = 108+primOpTag DoubleExpOp = 109+primOpTag DoubleLogOp = 110+primOpTag DoubleSqrtOp = 111+primOpTag DoubleSinOp = 112+primOpTag DoubleCosOp = 113+primOpTag DoubleTanOp = 114+primOpTag DoubleAsinOp = 115+primOpTag DoubleAcosOp = 116+primOpTag DoubleAtanOp = 117+primOpTag DoubleSinhOp = 118+primOpTag DoubleCoshOp = 119+primOpTag DoubleTanhOp = 120+primOpTag DoublePowerOp = 121+primOpTag DoubleDecode_2IntOp = 122+primOpTag DoubleDecode_Int64Op = 123+primOpTag FloatGtOp = 124+primOpTag FloatGeOp = 125+primOpTag FloatEqOp = 126+primOpTag FloatNeOp = 127+primOpTag FloatLtOp = 128+primOpTag FloatLeOp = 129+primOpTag FloatAddOp = 130+primOpTag FloatSubOp = 131+primOpTag FloatMulOp = 132+primOpTag FloatDivOp = 133+primOpTag FloatNegOp = 134+primOpTag FloatFabsOp = 135+primOpTag Float2IntOp = 136+primOpTag FloatExpOp = 137+primOpTag FloatLogOp = 138+primOpTag FloatSqrtOp = 139+primOpTag FloatSinOp = 140+primOpTag FloatCosOp = 141+primOpTag FloatTanOp = 142+primOpTag FloatAsinOp = 143+primOpTag FloatAcosOp = 144+primOpTag FloatAtanOp = 145+primOpTag FloatSinhOp = 146+primOpTag FloatCoshOp = 147+primOpTag FloatTanhOp = 148+primOpTag FloatPowerOp = 149+primOpTag Float2DoubleOp = 150+primOpTag FloatDecode_IntOp = 151+primOpTag NewArrayOp = 152+primOpTag SameMutableArrayOp = 153+primOpTag ReadArrayOp = 154+primOpTag WriteArrayOp = 155+primOpTag SizeofArrayOp = 156+primOpTag SizeofMutableArrayOp = 157+primOpTag IndexArrayOp = 158+primOpTag UnsafeFreezeArrayOp = 159+primOpTag UnsafeThawArrayOp = 160+primOpTag CopyArrayOp = 161+primOpTag CopyMutableArrayOp = 162+primOpTag CloneArrayOp = 163+primOpTag CloneMutableArrayOp = 164+primOpTag FreezeArrayOp = 165+primOpTag ThawArrayOp = 166+primOpTag CasArrayOp = 167+primOpTag NewSmallArrayOp = 168+primOpTag SameSmallMutableArrayOp = 169+primOpTag ReadSmallArrayOp = 170+primOpTag WriteSmallArrayOp = 171+primOpTag SizeofSmallArrayOp = 172+primOpTag SizeofSmallMutableArrayOp = 173+primOpTag IndexSmallArrayOp = 174+primOpTag UnsafeFreezeSmallArrayOp = 175+primOpTag UnsafeThawSmallArrayOp = 176+primOpTag CopySmallArrayOp = 177+primOpTag CopySmallMutableArrayOp = 178+primOpTag CloneSmallArrayOp = 179+primOpTag CloneSmallMutableArrayOp = 180+primOpTag FreezeSmallArrayOp = 181+primOpTag ThawSmallArrayOp = 182+primOpTag CasSmallArrayOp = 183+primOpTag NewByteArrayOp_Char = 184+primOpTag NewPinnedByteArrayOp_Char = 185+primOpTag NewAlignedPinnedByteArrayOp_Char = 186+primOpTag MutableByteArrayIsPinnedOp = 187+primOpTag ByteArrayIsPinnedOp = 188+primOpTag ByteArrayContents_Char = 189+primOpTag SameMutableByteArrayOp = 190+primOpTag ShrinkMutableByteArrayOp_Char = 191+primOpTag ResizeMutableByteArrayOp_Char = 192+primOpTag UnsafeFreezeByteArrayOp = 193+primOpTag SizeofByteArrayOp = 194+primOpTag SizeofMutableByteArrayOp = 195+primOpTag GetSizeofMutableByteArrayOp = 196+primOpTag IndexByteArrayOp_Char = 197+primOpTag IndexByteArrayOp_WideChar = 198+primOpTag IndexByteArrayOp_Int = 199+primOpTag IndexByteArrayOp_Word = 200+primOpTag IndexByteArrayOp_Addr = 201+primOpTag IndexByteArrayOp_Float = 202+primOpTag IndexByteArrayOp_Double = 203+primOpTag IndexByteArrayOp_StablePtr = 204+primOpTag IndexByteArrayOp_Int8 = 205+primOpTag IndexByteArrayOp_Int16 = 206+primOpTag IndexByteArrayOp_Int32 = 207+primOpTag IndexByteArrayOp_Int64 = 208+primOpTag IndexByteArrayOp_Word8 = 209+primOpTag IndexByteArrayOp_Word16 = 210+primOpTag IndexByteArrayOp_Word32 = 211+primOpTag IndexByteArrayOp_Word64 = 212+primOpTag ReadByteArrayOp_Char = 213+primOpTag ReadByteArrayOp_WideChar = 214+primOpTag ReadByteArrayOp_Int = 215+primOpTag ReadByteArrayOp_Word = 216+primOpTag ReadByteArrayOp_Addr = 217+primOpTag ReadByteArrayOp_Float = 218+primOpTag ReadByteArrayOp_Double = 219+primOpTag ReadByteArrayOp_StablePtr = 220+primOpTag ReadByteArrayOp_Int8 = 221+primOpTag ReadByteArrayOp_Int16 = 222+primOpTag ReadByteArrayOp_Int32 = 223+primOpTag ReadByteArrayOp_Int64 = 224+primOpTag ReadByteArrayOp_Word8 = 225+primOpTag ReadByteArrayOp_Word16 = 226+primOpTag ReadByteArrayOp_Word32 = 227+primOpTag ReadByteArrayOp_Word64 = 228+primOpTag WriteByteArrayOp_Char = 229+primOpTag WriteByteArrayOp_WideChar = 230+primOpTag WriteByteArrayOp_Int = 231+primOpTag WriteByteArrayOp_Word = 232+primOpTag WriteByteArrayOp_Addr = 233+primOpTag WriteByteArrayOp_Float = 234+primOpTag WriteByteArrayOp_Double = 235+primOpTag WriteByteArrayOp_StablePtr = 236+primOpTag WriteByteArrayOp_Int8 = 237+primOpTag WriteByteArrayOp_Int16 = 238+primOpTag WriteByteArrayOp_Int32 = 239+primOpTag WriteByteArrayOp_Int64 = 240+primOpTag WriteByteArrayOp_Word8 = 241+primOpTag WriteByteArrayOp_Word16 = 242+primOpTag WriteByteArrayOp_Word32 = 243+primOpTag WriteByteArrayOp_Word64 = 244+primOpTag CompareByteArraysOp = 245+primOpTag CopyByteArrayOp = 246+primOpTag CopyMutableByteArrayOp = 247+primOpTag CopyByteArrayToAddrOp = 248+primOpTag CopyMutableByteArrayToAddrOp = 249+primOpTag CopyAddrToByteArrayOp = 250+primOpTag SetByteArrayOp = 251+primOpTag AtomicReadByteArrayOp_Int = 252+primOpTag AtomicWriteByteArrayOp_Int = 253+primOpTag CasByteArrayOp_Int = 254+primOpTag FetchAddByteArrayOp_Int = 255+primOpTag FetchSubByteArrayOp_Int = 256+primOpTag FetchAndByteArrayOp_Int = 257+primOpTag FetchNandByteArrayOp_Int = 258+primOpTag FetchOrByteArrayOp_Int = 259+primOpTag FetchXorByteArrayOp_Int = 260+primOpTag NewArrayArrayOp = 261+primOpTag SameMutableArrayArrayOp = 262+primOpTag UnsafeFreezeArrayArrayOp = 263+primOpTag SizeofArrayArrayOp = 264+primOpTag SizeofMutableArrayArrayOp = 265+primOpTag IndexArrayArrayOp_ByteArray = 266+primOpTag IndexArrayArrayOp_ArrayArray = 267+primOpTag ReadArrayArrayOp_ByteArray = 268+primOpTag ReadArrayArrayOp_MutableByteArray = 269+primOpTag ReadArrayArrayOp_ArrayArray = 270+primOpTag ReadArrayArrayOp_MutableArrayArray = 271+primOpTag WriteArrayArrayOp_ByteArray = 272+primOpTag WriteArrayArrayOp_MutableByteArray = 273+primOpTag WriteArrayArrayOp_ArrayArray = 274+primOpTag WriteArrayArrayOp_MutableArrayArray = 275+primOpTag CopyArrayArrayOp = 276+primOpTag CopyMutableArrayArrayOp = 277+primOpTag AddrAddOp = 278+primOpTag AddrSubOp = 279+primOpTag AddrRemOp = 280+primOpTag Addr2IntOp = 281+primOpTag Int2AddrOp = 282+primOpTag AddrGtOp = 283+primOpTag AddrGeOp = 284+primOpTag AddrEqOp = 285+primOpTag AddrNeOp = 286+primOpTag AddrLtOp = 287+primOpTag AddrLeOp = 288+primOpTag IndexOffAddrOp_Char = 289+primOpTag IndexOffAddrOp_WideChar = 290+primOpTag IndexOffAddrOp_Int = 291+primOpTag IndexOffAddrOp_Word = 292+primOpTag IndexOffAddrOp_Addr = 293+primOpTag IndexOffAddrOp_Float = 294+primOpTag IndexOffAddrOp_Double = 295+primOpTag IndexOffAddrOp_StablePtr = 296+primOpTag IndexOffAddrOp_Int8 = 297+primOpTag IndexOffAddrOp_Int16 = 298+primOpTag IndexOffAddrOp_Int32 = 299+primOpTag IndexOffAddrOp_Int64 = 300+primOpTag IndexOffAddrOp_Word8 = 301+primOpTag IndexOffAddrOp_Word16 = 302+primOpTag IndexOffAddrOp_Word32 = 303+primOpTag IndexOffAddrOp_Word64 = 304+primOpTag ReadOffAddrOp_Char = 305+primOpTag ReadOffAddrOp_WideChar = 306+primOpTag ReadOffAddrOp_Int = 307+primOpTag ReadOffAddrOp_Word = 308+primOpTag ReadOffAddrOp_Addr = 309+primOpTag ReadOffAddrOp_Float = 310+primOpTag ReadOffAddrOp_Double = 311+primOpTag ReadOffAddrOp_StablePtr = 312+primOpTag ReadOffAddrOp_Int8 = 313+primOpTag ReadOffAddrOp_Int16 = 314+primOpTag ReadOffAddrOp_Int32 = 315+primOpTag ReadOffAddrOp_Int64 = 316+primOpTag ReadOffAddrOp_Word8 = 317+primOpTag ReadOffAddrOp_Word16 = 318+primOpTag ReadOffAddrOp_Word32 = 319+primOpTag ReadOffAddrOp_Word64 = 320+primOpTag WriteOffAddrOp_Char = 321+primOpTag WriteOffAddrOp_WideChar = 322+primOpTag WriteOffAddrOp_Int = 323+primOpTag WriteOffAddrOp_Word = 324+primOpTag WriteOffAddrOp_Addr = 325+primOpTag WriteOffAddrOp_Float = 326+primOpTag WriteOffAddrOp_Double = 327+primOpTag WriteOffAddrOp_StablePtr = 328+primOpTag WriteOffAddrOp_Int8 = 329+primOpTag WriteOffAddrOp_Int16 = 330+primOpTag WriteOffAddrOp_Int32 = 331+primOpTag WriteOffAddrOp_Int64 = 332+primOpTag WriteOffAddrOp_Word8 = 333+primOpTag WriteOffAddrOp_Word16 = 334+primOpTag WriteOffAddrOp_Word32 = 335+primOpTag WriteOffAddrOp_Word64 = 336+primOpTag NewMutVarOp = 337+primOpTag ReadMutVarOp = 338+primOpTag WriteMutVarOp = 339+primOpTag SameMutVarOp = 340+primOpTag AtomicModifyMutVarOp = 341+primOpTag CasMutVarOp = 342+primOpTag CatchOp = 343+primOpTag RaiseOp = 344+primOpTag RaiseIOOp = 345+primOpTag MaskAsyncExceptionsOp = 346+primOpTag MaskUninterruptibleOp = 347+primOpTag UnmaskAsyncExceptionsOp = 348+primOpTag MaskStatus = 349+primOpTag AtomicallyOp = 350+primOpTag RetryOp = 351+primOpTag CatchRetryOp = 352+primOpTag CatchSTMOp = 353+primOpTag Check = 354+primOpTag NewTVarOp = 355+primOpTag ReadTVarOp = 356+primOpTag ReadTVarIOOp = 357+primOpTag WriteTVarOp = 358+primOpTag SameTVarOp = 359+primOpTag NewMVarOp = 360+primOpTag TakeMVarOp = 361+primOpTag TryTakeMVarOp = 362+primOpTag PutMVarOp = 363+primOpTag TryPutMVarOp = 364+primOpTag ReadMVarOp = 365+primOpTag TryReadMVarOp = 366+primOpTag SameMVarOp = 367+primOpTag IsEmptyMVarOp = 368+primOpTag DelayOp = 369+primOpTag WaitReadOp = 370+primOpTag WaitWriteOp = 371+primOpTag ForkOp = 372+primOpTag ForkOnOp = 373+primOpTag KillThreadOp = 374+primOpTag YieldOp = 375+primOpTag MyThreadIdOp = 376+primOpTag LabelThreadOp = 377+primOpTag IsCurrentThreadBoundOp = 378+primOpTag NoDuplicateOp = 379+primOpTag ThreadStatusOp = 380+primOpTag MkWeakOp = 381+primOpTag MkWeakNoFinalizerOp = 382+primOpTag AddCFinalizerToWeakOp = 383+primOpTag DeRefWeakOp = 384+primOpTag FinalizeWeakOp = 385+primOpTag TouchOp = 386+primOpTag MakeStablePtrOp = 387+primOpTag DeRefStablePtrOp = 388+primOpTag EqStablePtrOp = 389+primOpTag MakeStableNameOp = 390+primOpTag EqStableNameOp = 391+primOpTag StableNameToIntOp = 392+primOpTag CompactNewOp = 393+primOpTag CompactResizeOp = 394+primOpTag CompactContainsOp = 395+primOpTag CompactContainsAnyOp = 396+primOpTag CompactGetFirstBlockOp = 397+primOpTag CompactGetNextBlockOp = 398+primOpTag CompactAllocateBlockOp = 399+primOpTag CompactFixupPointersOp = 400+primOpTag CompactAdd = 401+primOpTag CompactAddWithSharing = 402+primOpTag CompactSize = 403+primOpTag ReallyUnsafePtrEqualityOp = 404+primOpTag ParOp = 405+primOpTag SparkOp = 406+primOpTag SeqOp = 407+primOpTag GetSparkOp = 408+primOpTag NumSparks = 409+primOpTag DataToTagOp = 410+primOpTag TagToEnumOp = 411+primOpTag AddrToAnyOp = 412+primOpTag AnyToAddrOp = 413+primOpTag MkApUpd0_Op = 414+primOpTag NewBCOOp = 415+primOpTag UnpackClosureOp = 416+primOpTag GetApStackValOp = 417+primOpTag GetCCSOfOp = 418+primOpTag GetCurrentCCSOp = 419+primOpTag ClearCCSOp = 420+primOpTag TraceEventOp = 421+primOpTag TraceMarkerOp = 422+primOpTag (VecBroadcastOp IntVec 16 W8) = 423+primOpTag (VecBroadcastOp IntVec 8 W16) = 424+primOpTag (VecBroadcastOp IntVec 4 W32) = 425+primOpTag (VecBroadcastOp IntVec 2 W64) = 426+primOpTag (VecBroadcastOp IntVec 32 W8) = 427+primOpTag (VecBroadcastOp IntVec 16 W16) = 428+primOpTag (VecBroadcastOp IntVec 8 W32) = 429+primOpTag (VecBroadcastOp IntVec 4 W64) = 430+primOpTag (VecBroadcastOp IntVec 64 W8) = 431+primOpTag (VecBroadcastOp IntVec 32 W16) = 432+primOpTag (VecBroadcastOp IntVec 16 W32) = 433+primOpTag (VecBroadcastOp IntVec 8 W64) = 434+primOpTag (VecBroadcastOp WordVec 16 W8) = 435+primOpTag (VecBroadcastOp WordVec 8 W16) = 436+primOpTag (VecBroadcastOp WordVec 4 W32) = 437+primOpTag (VecBroadcastOp WordVec 2 W64) = 438+primOpTag (VecBroadcastOp WordVec 32 W8) = 439+primOpTag (VecBroadcastOp WordVec 16 W16) = 440+primOpTag (VecBroadcastOp WordVec 8 W32) = 441+primOpTag (VecBroadcastOp WordVec 4 W64) = 442+primOpTag (VecBroadcastOp WordVec 64 W8) = 443+primOpTag (VecBroadcastOp WordVec 32 W16) = 444+primOpTag (VecBroadcastOp WordVec 16 W32) = 445+primOpTag (VecBroadcastOp WordVec 8 W64) = 446+primOpTag (VecBroadcastOp FloatVec 4 W32) = 447+primOpTag (VecBroadcastOp FloatVec 2 W64) = 448+primOpTag (VecBroadcastOp FloatVec 8 W32) = 449+primOpTag (VecBroadcastOp FloatVec 4 W64) = 450+primOpTag (VecBroadcastOp FloatVec 16 W32) = 451+primOpTag (VecBroadcastOp FloatVec 8 W64) = 452+primOpTag (VecPackOp IntVec 16 W8) = 453+primOpTag (VecPackOp IntVec 8 W16) = 454+primOpTag (VecPackOp IntVec 4 W32) = 455+primOpTag (VecPackOp IntVec 2 W64) = 456+primOpTag (VecPackOp IntVec 32 W8) = 457+primOpTag (VecPackOp IntVec 16 W16) = 458+primOpTag (VecPackOp IntVec 8 W32) = 459+primOpTag (VecPackOp IntVec 4 W64) = 460+primOpTag (VecPackOp IntVec 64 W8) = 461+primOpTag (VecPackOp IntVec 32 W16) = 462+primOpTag (VecPackOp IntVec 16 W32) = 463+primOpTag (VecPackOp IntVec 8 W64) = 464+primOpTag (VecPackOp WordVec 16 W8) = 465+primOpTag (VecPackOp WordVec 8 W16) = 466+primOpTag (VecPackOp WordVec 4 W32) = 467+primOpTag (VecPackOp WordVec 2 W64) = 468+primOpTag (VecPackOp WordVec 32 W8) = 469+primOpTag (VecPackOp WordVec 16 W16) = 470+primOpTag (VecPackOp WordVec 8 W32) = 471+primOpTag (VecPackOp WordVec 4 W64) = 472+primOpTag (VecPackOp WordVec 64 W8) = 473+primOpTag (VecPackOp WordVec 32 W16) = 474+primOpTag (VecPackOp WordVec 16 W32) = 475+primOpTag (VecPackOp WordVec 8 W64) = 476+primOpTag (VecPackOp FloatVec 4 W32) = 477+primOpTag (VecPackOp FloatVec 2 W64) = 478+primOpTag (VecPackOp FloatVec 8 W32) = 479+primOpTag (VecPackOp FloatVec 4 W64) = 480+primOpTag (VecPackOp FloatVec 16 W32) = 481+primOpTag (VecPackOp FloatVec 8 W64) = 482+primOpTag (VecUnpackOp IntVec 16 W8) = 483+primOpTag (VecUnpackOp IntVec 8 W16) = 484+primOpTag (VecUnpackOp IntVec 4 W32) = 485+primOpTag (VecUnpackOp IntVec 2 W64) = 486+primOpTag (VecUnpackOp IntVec 32 W8) = 487+primOpTag (VecUnpackOp IntVec 16 W16) = 488+primOpTag (VecUnpackOp IntVec 8 W32) = 489+primOpTag (VecUnpackOp IntVec 4 W64) = 490+primOpTag (VecUnpackOp IntVec 64 W8) = 491+primOpTag (VecUnpackOp IntVec 32 W16) = 492+primOpTag (VecUnpackOp IntVec 16 W32) = 493+primOpTag (VecUnpackOp IntVec 8 W64) = 494+primOpTag (VecUnpackOp WordVec 16 W8) = 495+primOpTag (VecUnpackOp WordVec 8 W16) = 496+primOpTag (VecUnpackOp WordVec 4 W32) = 497+primOpTag (VecUnpackOp WordVec 2 W64) = 498+primOpTag (VecUnpackOp WordVec 32 W8) = 499+primOpTag (VecUnpackOp WordVec 16 W16) = 500+primOpTag (VecUnpackOp WordVec 8 W32) = 501+primOpTag (VecUnpackOp WordVec 4 W64) = 502+primOpTag (VecUnpackOp WordVec 64 W8) = 503+primOpTag (VecUnpackOp WordVec 32 W16) = 504+primOpTag (VecUnpackOp WordVec 16 W32) = 505+primOpTag (VecUnpackOp WordVec 8 W64) = 506+primOpTag (VecUnpackOp FloatVec 4 W32) = 507+primOpTag (VecUnpackOp FloatVec 2 W64) = 508+primOpTag (VecUnpackOp FloatVec 8 W32) = 509+primOpTag (VecUnpackOp FloatVec 4 W64) = 510+primOpTag (VecUnpackOp FloatVec 16 W32) = 511+primOpTag (VecUnpackOp FloatVec 8 W64) = 512+primOpTag (VecInsertOp IntVec 16 W8) = 513+primOpTag (VecInsertOp IntVec 8 W16) = 514+primOpTag (VecInsertOp IntVec 4 W32) = 515+primOpTag (VecInsertOp IntVec 2 W64) = 516+primOpTag (VecInsertOp IntVec 32 W8) = 517+primOpTag (VecInsertOp IntVec 16 W16) = 518+primOpTag (VecInsertOp IntVec 8 W32) = 519+primOpTag (VecInsertOp IntVec 4 W64) = 520+primOpTag (VecInsertOp IntVec 64 W8) = 521+primOpTag (VecInsertOp IntVec 32 W16) = 522+primOpTag (VecInsertOp IntVec 16 W32) = 523+primOpTag (VecInsertOp IntVec 8 W64) = 524+primOpTag (VecInsertOp WordVec 16 W8) = 525+primOpTag (VecInsertOp WordVec 8 W16) = 526+primOpTag (VecInsertOp WordVec 4 W32) = 527+primOpTag (VecInsertOp WordVec 2 W64) = 528+primOpTag (VecInsertOp WordVec 32 W8) = 529+primOpTag (VecInsertOp WordVec 16 W16) = 530+primOpTag (VecInsertOp WordVec 8 W32) = 531+primOpTag (VecInsertOp WordVec 4 W64) = 532+primOpTag (VecInsertOp WordVec 64 W8) = 533+primOpTag (VecInsertOp WordVec 32 W16) = 534+primOpTag (VecInsertOp WordVec 16 W32) = 535+primOpTag (VecInsertOp WordVec 8 W64) = 536+primOpTag (VecInsertOp FloatVec 4 W32) = 537+primOpTag (VecInsertOp FloatVec 2 W64) = 538+primOpTag (VecInsertOp FloatVec 8 W32) = 539+primOpTag (VecInsertOp FloatVec 4 W64) = 540+primOpTag (VecInsertOp FloatVec 16 W32) = 541+primOpTag (VecInsertOp FloatVec 8 W64) = 542+primOpTag (VecAddOp IntVec 16 W8) = 543+primOpTag (VecAddOp IntVec 8 W16) = 544+primOpTag (VecAddOp IntVec 4 W32) = 545+primOpTag (VecAddOp IntVec 2 W64) = 546+primOpTag (VecAddOp IntVec 32 W8) = 547+primOpTag (VecAddOp IntVec 16 W16) = 548+primOpTag (VecAddOp IntVec 8 W32) = 549+primOpTag (VecAddOp IntVec 4 W64) = 550+primOpTag (VecAddOp IntVec 64 W8) = 551+primOpTag (VecAddOp IntVec 32 W16) = 552+primOpTag (VecAddOp IntVec 16 W32) = 553+primOpTag (VecAddOp IntVec 8 W64) = 554+primOpTag (VecAddOp WordVec 16 W8) = 555+primOpTag (VecAddOp WordVec 8 W16) = 556+primOpTag (VecAddOp WordVec 4 W32) = 557+primOpTag (VecAddOp WordVec 2 W64) = 558+primOpTag (VecAddOp WordVec 32 W8) = 559+primOpTag (VecAddOp WordVec 16 W16) = 560+primOpTag (VecAddOp WordVec 8 W32) = 561+primOpTag (VecAddOp WordVec 4 W64) = 562+primOpTag (VecAddOp WordVec 64 W8) = 563+primOpTag (VecAddOp WordVec 32 W16) = 564+primOpTag (VecAddOp WordVec 16 W32) = 565+primOpTag (VecAddOp WordVec 8 W64) = 566+primOpTag (VecAddOp FloatVec 4 W32) = 567+primOpTag (VecAddOp FloatVec 2 W64) = 568+primOpTag (VecAddOp FloatVec 8 W32) = 569+primOpTag (VecAddOp FloatVec 4 W64) = 570+primOpTag (VecAddOp FloatVec 16 W32) = 571+primOpTag (VecAddOp FloatVec 8 W64) = 572+primOpTag (VecSubOp IntVec 16 W8) = 573+primOpTag (VecSubOp IntVec 8 W16) = 574+primOpTag (VecSubOp IntVec 4 W32) = 575+primOpTag (VecSubOp IntVec 2 W64) = 576+primOpTag (VecSubOp IntVec 32 W8) = 577+primOpTag (VecSubOp IntVec 16 W16) = 578+primOpTag (VecSubOp IntVec 8 W32) = 579+primOpTag (VecSubOp IntVec 4 W64) = 580+primOpTag (VecSubOp IntVec 64 W8) = 581+primOpTag (VecSubOp IntVec 32 W16) = 582+primOpTag (VecSubOp IntVec 16 W32) = 583+primOpTag (VecSubOp IntVec 8 W64) = 584+primOpTag (VecSubOp WordVec 16 W8) = 585+primOpTag (VecSubOp WordVec 8 W16) = 586+primOpTag (VecSubOp WordVec 4 W32) = 587+primOpTag (VecSubOp WordVec 2 W64) = 588+primOpTag (VecSubOp WordVec 32 W8) = 589+primOpTag (VecSubOp WordVec 16 W16) = 590+primOpTag (VecSubOp WordVec 8 W32) = 591+primOpTag (VecSubOp WordVec 4 W64) = 592+primOpTag (VecSubOp WordVec 64 W8) = 593+primOpTag (VecSubOp WordVec 32 W16) = 594+primOpTag (VecSubOp WordVec 16 W32) = 595+primOpTag (VecSubOp WordVec 8 W64) = 596+primOpTag (VecSubOp FloatVec 4 W32) = 597+primOpTag (VecSubOp FloatVec 2 W64) = 598+primOpTag (VecSubOp FloatVec 8 W32) = 599+primOpTag (VecSubOp FloatVec 4 W64) = 600+primOpTag (VecSubOp FloatVec 16 W32) = 601+primOpTag (VecSubOp FloatVec 8 W64) = 602+primOpTag (VecMulOp IntVec 16 W8) = 603+primOpTag (VecMulOp IntVec 8 W16) = 604+primOpTag (VecMulOp IntVec 4 W32) = 605+primOpTag (VecMulOp IntVec 2 W64) = 606+primOpTag (VecMulOp IntVec 32 W8) = 607+primOpTag (VecMulOp IntVec 16 W16) = 608+primOpTag (VecMulOp IntVec 8 W32) = 609+primOpTag (VecMulOp IntVec 4 W64) = 610+primOpTag (VecMulOp IntVec 64 W8) = 611+primOpTag (VecMulOp IntVec 32 W16) = 612+primOpTag (VecMulOp IntVec 16 W32) = 613+primOpTag (VecMulOp IntVec 8 W64) = 614+primOpTag (VecMulOp WordVec 16 W8) = 615+primOpTag (VecMulOp WordVec 8 W16) = 616+primOpTag (VecMulOp WordVec 4 W32) = 617+primOpTag (VecMulOp WordVec 2 W64) = 618+primOpTag (VecMulOp WordVec 32 W8) = 619+primOpTag (VecMulOp WordVec 16 W16) = 620+primOpTag (VecMulOp WordVec 8 W32) = 621+primOpTag (VecMulOp WordVec 4 W64) = 622+primOpTag (VecMulOp WordVec 64 W8) = 623+primOpTag (VecMulOp WordVec 32 W16) = 624+primOpTag (VecMulOp WordVec 16 W32) = 625+primOpTag (VecMulOp WordVec 8 W64) = 626+primOpTag (VecMulOp FloatVec 4 W32) = 627+primOpTag (VecMulOp FloatVec 2 W64) = 628+primOpTag (VecMulOp FloatVec 8 W32) = 629+primOpTag (VecMulOp FloatVec 4 W64) = 630+primOpTag (VecMulOp FloatVec 16 W32) = 631+primOpTag (VecMulOp FloatVec 8 W64) = 632+primOpTag (VecDivOp FloatVec 4 W32) = 633+primOpTag (VecDivOp FloatVec 2 W64) = 634+primOpTag (VecDivOp FloatVec 8 W32) = 635+primOpTag (VecDivOp FloatVec 4 W64) = 636+primOpTag (VecDivOp FloatVec 16 W32) = 637+primOpTag (VecDivOp FloatVec 8 W64) = 638+primOpTag (VecQuotOp IntVec 16 W8) = 639+primOpTag (VecQuotOp IntVec 8 W16) = 640+primOpTag (VecQuotOp IntVec 4 W32) = 641+primOpTag (VecQuotOp IntVec 2 W64) = 642+primOpTag (VecQuotOp IntVec 32 W8) = 643+primOpTag (VecQuotOp IntVec 16 W16) = 644+primOpTag (VecQuotOp IntVec 8 W32) = 645+primOpTag (VecQuotOp IntVec 4 W64) = 646+primOpTag (VecQuotOp IntVec 64 W8) = 647+primOpTag (VecQuotOp IntVec 32 W16) = 648+primOpTag (VecQuotOp IntVec 16 W32) = 649+primOpTag (VecQuotOp IntVec 8 W64) = 650+primOpTag (VecQuotOp WordVec 16 W8) = 651+primOpTag (VecQuotOp WordVec 8 W16) = 652+primOpTag (VecQuotOp WordVec 4 W32) = 653+primOpTag (VecQuotOp WordVec 2 W64) = 654+primOpTag (VecQuotOp WordVec 32 W8) = 655+primOpTag (VecQuotOp WordVec 16 W16) = 656+primOpTag (VecQuotOp WordVec 8 W32) = 657+primOpTag (VecQuotOp WordVec 4 W64) = 658+primOpTag (VecQuotOp WordVec 64 W8) = 659+primOpTag (VecQuotOp WordVec 32 W16) = 660+primOpTag (VecQuotOp WordVec 16 W32) = 661+primOpTag (VecQuotOp WordVec 8 W64) = 662+primOpTag (VecRemOp IntVec 16 W8) = 663+primOpTag (VecRemOp IntVec 8 W16) = 664+primOpTag (VecRemOp IntVec 4 W32) = 665+primOpTag (VecRemOp IntVec 2 W64) = 666+primOpTag (VecRemOp IntVec 32 W8) = 667+primOpTag (VecRemOp IntVec 16 W16) = 668+primOpTag (VecRemOp IntVec 8 W32) = 669+primOpTag (VecRemOp IntVec 4 W64) = 670+primOpTag (VecRemOp IntVec 64 W8) = 671+primOpTag (VecRemOp IntVec 32 W16) = 672+primOpTag (VecRemOp IntVec 16 W32) = 673+primOpTag (VecRemOp IntVec 8 W64) = 674+primOpTag (VecRemOp WordVec 16 W8) = 675+primOpTag (VecRemOp WordVec 8 W16) = 676+primOpTag (VecRemOp WordVec 4 W32) = 677+primOpTag (VecRemOp WordVec 2 W64) = 678+primOpTag (VecRemOp WordVec 32 W8) = 679+primOpTag (VecRemOp WordVec 16 W16) = 680+primOpTag (VecRemOp WordVec 8 W32) = 681+primOpTag (VecRemOp WordVec 4 W64) = 682+primOpTag (VecRemOp WordVec 64 W8) = 683+primOpTag (VecRemOp WordVec 32 W16) = 684+primOpTag (VecRemOp WordVec 16 W32) = 685+primOpTag (VecRemOp WordVec 8 W64) = 686+primOpTag (VecNegOp IntVec 16 W8) = 687+primOpTag (VecNegOp IntVec 8 W16) = 688+primOpTag (VecNegOp IntVec 4 W32) = 689+primOpTag (VecNegOp IntVec 2 W64) = 690+primOpTag (VecNegOp IntVec 32 W8) = 691+primOpTag (VecNegOp IntVec 16 W16) = 692+primOpTag (VecNegOp IntVec 8 W32) = 693+primOpTag (VecNegOp IntVec 4 W64) = 694+primOpTag (VecNegOp IntVec 64 W8) = 695+primOpTag (VecNegOp IntVec 32 W16) = 696+primOpTag (VecNegOp IntVec 16 W32) = 697+primOpTag (VecNegOp IntVec 8 W64) = 698+primOpTag (VecNegOp FloatVec 4 W32) = 699+primOpTag (VecNegOp FloatVec 2 W64) = 700+primOpTag (VecNegOp FloatVec 8 W32) = 701+primOpTag (VecNegOp FloatVec 4 W64) = 702+primOpTag (VecNegOp FloatVec 16 W32) = 703+primOpTag (VecNegOp FloatVec 8 W64) = 704+primOpTag (VecIndexByteArrayOp IntVec 16 W8) = 705+primOpTag (VecIndexByteArrayOp IntVec 8 W16) = 706+primOpTag (VecIndexByteArrayOp IntVec 4 W32) = 707+primOpTag (VecIndexByteArrayOp IntVec 2 W64) = 708+primOpTag (VecIndexByteArrayOp IntVec 32 W8) = 709+primOpTag (VecIndexByteArrayOp IntVec 16 W16) = 710+primOpTag (VecIndexByteArrayOp IntVec 8 W32) = 711+primOpTag (VecIndexByteArrayOp IntVec 4 W64) = 712+primOpTag (VecIndexByteArrayOp IntVec 64 W8) = 713+primOpTag (VecIndexByteArrayOp IntVec 32 W16) = 714+primOpTag (VecIndexByteArrayOp IntVec 16 W32) = 715+primOpTag (VecIndexByteArrayOp IntVec 8 W64) = 716+primOpTag (VecIndexByteArrayOp WordVec 16 W8) = 717+primOpTag (VecIndexByteArrayOp WordVec 8 W16) = 718+primOpTag (VecIndexByteArrayOp WordVec 4 W32) = 719+primOpTag (VecIndexByteArrayOp WordVec 2 W64) = 720+primOpTag (VecIndexByteArrayOp WordVec 32 W8) = 721+primOpTag (VecIndexByteArrayOp WordVec 16 W16) = 722+primOpTag (VecIndexByteArrayOp WordVec 8 W32) = 723+primOpTag (VecIndexByteArrayOp WordVec 4 W64) = 724+primOpTag (VecIndexByteArrayOp WordVec 64 W8) = 725+primOpTag (VecIndexByteArrayOp WordVec 32 W16) = 726+primOpTag (VecIndexByteArrayOp WordVec 16 W32) = 727+primOpTag (VecIndexByteArrayOp WordVec 8 W64) = 728+primOpTag (VecIndexByteArrayOp FloatVec 4 W32) = 729+primOpTag (VecIndexByteArrayOp FloatVec 2 W64) = 730+primOpTag (VecIndexByteArrayOp FloatVec 8 W32) = 731+primOpTag (VecIndexByteArrayOp FloatVec 4 W64) = 732+primOpTag (VecIndexByteArrayOp FloatVec 16 W32) = 733+primOpTag (VecIndexByteArrayOp FloatVec 8 W64) = 734+primOpTag (VecReadByteArrayOp IntVec 16 W8) = 735+primOpTag (VecReadByteArrayOp IntVec 8 W16) = 736+primOpTag (VecReadByteArrayOp IntVec 4 W32) = 737+primOpTag (VecReadByteArrayOp IntVec 2 W64) = 738+primOpTag (VecReadByteArrayOp IntVec 32 W8) = 739+primOpTag (VecReadByteArrayOp IntVec 16 W16) = 740+primOpTag (VecReadByteArrayOp IntVec 8 W32) = 741+primOpTag (VecReadByteArrayOp IntVec 4 W64) = 742+primOpTag (VecReadByteArrayOp IntVec 64 W8) = 743+primOpTag (VecReadByteArrayOp IntVec 32 W16) = 744+primOpTag (VecReadByteArrayOp IntVec 16 W32) = 745+primOpTag (VecReadByteArrayOp IntVec 8 W64) = 746+primOpTag (VecReadByteArrayOp WordVec 16 W8) = 747+primOpTag (VecReadByteArrayOp WordVec 8 W16) = 748+primOpTag (VecReadByteArrayOp WordVec 4 W32) = 749+primOpTag (VecReadByteArrayOp WordVec 2 W64) = 750+primOpTag (VecReadByteArrayOp WordVec 32 W8) = 751+primOpTag (VecReadByteArrayOp WordVec 16 W16) = 752+primOpTag (VecReadByteArrayOp WordVec 8 W32) = 753+primOpTag (VecReadByteArrayOp WordVec 4 W64) = 754+primOpTag (VecReadByteArrayOp WordVec 64 W8) = 755+primOpTag (VecReadByteArrayOp WordVec 32 W16) = 756+primOpTag (VecReadByteArrayOp WordVec 16 W32) = 757+primOpTag (VecReadByteArrayOp WordVec 8 W64) = 758+primOpTag (VecReadByteArrayOp FloatVec 4 W32) = 759+primOpTag (VecReadByteArrayOp FloatVec 2 W64) = 760+primOpTag (VecReadByteArrayOp FloatVec 8 W32) = 761+primOpTag (VecReadByteArrayOp FloatVec 4 W64) = 762+primOpTag (VecReadByteArrayOp FloatVec 16 W32) = 763+primOpTag (VecReadByteArrayOp FloatVec 8 W64) = 764+primOpTag (VecWriteByteArrayOp IntVec 16 W8) = 765+primOpTag (VecWriteByteArrayOp IntVec 8 W16) = 766+primOpTag (VecWriteByteArrayOp IntVec 4 W32) = 767+primOpTag (VecWriteByteArrayOp IntVec 2 W64) = 768+primOpTag (VecWriteByteArrayOp IntVec 32 W8) = 769+primOpTag (VecWriteByteArrayOp IntVec 16 W16) = 770+primOpTag (VecWriteByteArrayOp IntVec 8 W32) = 771+primOpTag (VecWriteByteArrayOp IntVec 4 W64) = 772+primOpTag (VecWriteByteArrayOp IntVec 64 W8) = 773+primOpTag (VecWriteByteArrayOp IntVec 32 W16) = 774+primOpTag (VecWriteByteArrayOp IntVec 16 W32) = 775+primOpTag (VecWriteByteArrayOp IntVec 8 W64) = 776+primOpTag (VecWriteByteArrayOp WordVec 16 W8) = 777+primOpTag (VecWriteByteArrayOp WordVec 8 W16) = 778+primOpTag (VecWriteByteArrayOp WordVec 4 W32) = 779+primOpTag (VecWriteByteArrayOp WordVec 2 W64) = 780+primOpTag (VecWriteByteArrayOp WordVec 32 W8) = 781+primOpTag (VecWriteByteArrayOp WordVec 16 W16) = 782+primOpTag (VecWriteByteArrayOp WordVec 8 W32) = 783+primOpTag (VecWriteByteArrayOp WordVec 4 W64) = 784+primOpTag (VecWriteByteArrayOp WordVec 64 W8) = 785+primOpTag (VecWriteByteArrayOp WordVec 32 W16) = 786+primOpTag (VecWriteByteArrayOp WordVec 16 W32) = 787+primOpTag (VecWriteByteArrayOp WordVec 8 W64) = 788+primOpTag (VecWriteByteArrayOp FloatVec 4 W32) = 789+primOpTag (VecWriteByteArrayOp FloatVec 2 W64) = 790+primOpTag (VecWriteByteArrayOp FloatVec 8 W32) = 791+primOpTag (VecWriteByteArrayOp FloatVec 4 W64) = 792+primOpTag (VecWriteByteArrayOp FloatVec 16 W32) = 793+primOpTag (VecWriteByteArrayOp FloatVec 8 W64) = 794+primOpTag (VecIndexOffAddrOp IntVec 16 W8) = 795+primOpTag (VecIndexOffAddrOp IntVec 8 W16) = 796+primOpTag (VecIndexOffAddrOp IntVec 4 W32) = 797+primOpTag (VecIndexOffAddrOp IntVec 2 W64) = 798+primOpTag (VecIndexOffAddrOp IntVec 32 W8) = 799+primOpTag (VecIndexOffAddrOp IntVec 16 W16) = 800+primOpTag (VecIndexOffAddrOp IntVec 8 W32) = 801+primOpTag (VecIndexOffAddrOp IntVec 4 W64) = 802+primOpTag (VecIndexOffAddrOp IntVec 64 W8) = 803+primOpTag (VecIndexOffAddrOp IntVec 32 W16) = 804+primOpTag (VecIndexOffAddrOp IntVec 16 W32) = 805+primOpTag (VecIndexOffAddrOp IntVec 8 W64) = 806+primOpTag (VecIndexOffAddrOp WordVec 16 W8) = 807+primOpTag (VecIndexOffAddrOp WordVec 8 W16) = 808+primOpTag (VecIndexOffAddrOp WordVec 4 W32) = 809+primOpTag (VecIndexOffAddrOp WordVec 2 W64) = 810+primOpTag (VecIndexOffAddrOp WordVec 32 W8) = 811+primOpTag (VecIndexOffAddrOp WordVec 16 W16) = 812+primOpTag (VecIndexOffAddrOp WordVec 8 W32) = 813+primOpTag (VecIndexOffAddrOp WordVec 4 W64) = 814+primOpTag (VecIndexOffAddrOp WordVec 64 W8) = 815+primOpTag (VecIndexOffAddrOp WordVec 32 W16) = 816+primOpTag (VecIndexOffAddrOp WordVec 16 W32) = 817+primOpTag (VecIndexOffAddrOp WordVec 8 W64) = 818+primOpTag (VecIndexOffAddrOp FloatVec 4 W32) = 819+primOpTag (VecIndexOffAddrOp FloatVec 2 W64) = 820+primOpTag (VecIndexOffAddrOp FloatVec 8 W32) = 821+primOpTag (VecIndexOffAddrOp FloatVec 4 W64) = 822+primOpTag (VecIndexOffAddrOp FloatVec 16 W32) = 823+primOpTag (VecIndexOffAddrOp FloatVec 8 W64) = 824+primOpTag (VecReadOffAddrOp IntVec 16 W8) = 825+primOpTag (VecReadOffAddrOp IntVec 8 W16) = 826+primOpTag (VecReadOffAddrOp IntVec 4 W32) = 827+primOpTag (VecReadOffAddrOp IntVec 2 W64) = 828+primOpTag (VecReadOffAddrOp IntVec 32 W8) = 829+primOpTag (VecReadOffAddrOp IntVec 16 W16) = 830+primOpTag (VecReadOffAddrOp IntVec 8 W32) = 831+primOpTag (VecReadOffAddrOp IntVec 4 W64) = 832+primOpTag (VecReadOffAddrOp IntVec 64 W8) = 833+primOpTag (VecReadOffAddrOp IntVec 32 W16) = 834+primOpTag (VecReadOffAddrOp IntVec 16 W32) = 835+primOpTag (VecReadOffAddrOp IntVec 8 W64) = 836+primOpTag (VecReadOffAddrOp WordVec 16 W8) = 837+primOpTag (VecReadOffAddrOp WordVec 8 W16) = 838+primOpTag (VecReadOffAddrOp WordVec 4 W32) = 839+primOpTag (VecReadOffAddrOp WordVec 2 W64) = 840+primOpTag (VecReadOffAddrOp WordVec 32 W8) = 841+primOpTag (VecReadOffAddrOp WordVec 16 W16) = 842+primOpTag (VecReadOffAddrOp WordVec 8 W32) = 843+primOpTag (VecReadOffAddrOp WordVec 4 W64) = 844+primOpTag (VecReadOffAddrOp WordVec 64 W8) = 845+primOpTag (VecReadOffAddrOp WordVec 32 W16) = 846+primOpTag (VecReadOffAddrOp WordVec 16 W32) = 847+primOpTag (VecReadOffAddrOp WordVec 8 W64) = 848+primOpTag (VecReadOffAddrOp FloatVec 4 W32) = 849+primOpTag (VecReadOffAddrOp FloatVec 2 W64) = 850+primOpTag (VecReadOffAddrOp FloatVec 8 W32) = 851+primOpTag (VecReadOffAddrOp FloatVec 4 W64) = 852+primOpTag (VecReadOffAddrOp FloatVec 16 W32) = 853+primOpTag (VecReadOffAddrOp FloatVec 8 W64) = 854+primOpTag (VecWriteOffAddrOp IntVec 16 W8) = 855+primOpTag (VecWriteOffAddrOp IntVec 8 W16) = 856+primOpTag (VecWriteOffAddrOp IntVec 4 W32) = 857+primOpTag (VecWriteOffAddrOp IntVec 2 W64) = 858+primOpTag (VecWriteOffAddrOp IntVec 32 W8) = 859+primOpTag (VecWriteOffAddrOp IntVec 16 W16) = 860+primOpTag (VecWriteOffAddrOp IntVec 8 W32) = 861+primOpTag (VecWriteOffAddrOp IntVec 4 W64) = 862+primOpTag (VecWriteOffAddrOp IntVec 64 W8) = 863+primOpTag (VecWriteOffAddrOp IntVec 32 W16) = 864+primOpTag (VecWriteOffAddrOp IntVec 16 W32) = 865+primOpTag (VecWriteOffAddrOp IntVec 8 W64) = 866+primOpTag (VecWriteOffAddrOp WordVec 16 W8) = 867+primOpTag (VecWriteOffAddrOp WordVec 8 W16) = 868+primOpTag (VecWriteOffAddrOp WordVec 4 W32) = 869+primOpTag (VecWriteOffAddrOp WordVec 2 W64) = 870+primOpTag (VecWriteOffAddrOp WordVec 32 W8) = 871+primOpTag (VecWriteOffAddrOp WordVec 16 W16) = 872+primOpTag (VecWriteOffAddrOp WordVec 8 W32) = 873+primOpTag (VecWriteOffAddrOp WordVec 4 W64) = 874+primOpTag (VecWriteOffAddrOp WordVec 64 W8) = 875+primOpTag (VecWriteOffAddrOp WordVec 32 W16) = 876+primOpTag (VecWriteOffAddrOp WordVec 16 W32) = 877+primOpTag (VecWriteOffAddrOp WordVec 8 W64) = 878+primOpTag (VecWriteOffAddrOp FloatVec 4 W32) = 879+primOpTag (VecWriteOffAddrOp FloatVec 2 W64) = 880+primOpTag (VecWriteOffAddrOp FloatVec 8 W32) = 881+primOpTag (VecWriteOffAddrOp FloatVec 4 W64) = 882+primOpTag (VecWriteOffAddrOp FloatVec 16 W32) = 883+primOpTag (VecWriteOffAddrOp FloatVec 8 W64) = 884+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W8) = 885+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W16) = 886+primOpTag (VecIndexScalarByteArrayOp IntVec 4 W32) = 887+primOpTag (VecIndexScalarByteArrayOp IntVec 2 W64) = 888+primOpTag (VecIndexScalarByteArrayOp IntVec 32 W8) = 889+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W16) = 890+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W32) = 891+primOpTag (VecIndexScalarByteArrayOp IntVec 4 W64) = 892+primOpTag (VecIndexScalarByteArrayOp IntVec 64 W8) = 893+primOpTag (VecIndexScalarByteArrayOp IntVec 32 W16) = 894+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W32) = 895+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W64) = 896+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W8) = 897+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W16) = 898+primOpTag (VecIndexScalarByteArrayOp WordVec 4 W32) = 899+primOpTag (VecIndexScalarByteArrayOp WordVec 2 W64) = 900+primOpTag (VecIndexScalarByteArrayOp WordVec 32 W8) = 901+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W16) = 902+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W32) = 903+primOpTag (VecIndexScalarByteArrayOp WordVec 4 W64) = 904+primOpTag (VecIndexScalarByteArrayOp WordVec 64 W8) = 905+primOpTag (VecIndexScalarByteArrayOp WordVec 32 W16) = 906+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W32) = 907+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W64) = 908+primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W32) = 909+primOpTag (VecIndexScalarByteArrayOp FloatVec 2 W64) = 910+primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W32) = 911+primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W64) = 912+primOpTag (VecIndexScalarByteArrayOp FloatVec 16 W32) = 913+primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W64) = 914+primOpTag (VecReadScalarByteArrayOp IntVec 16 W8) = 915+primOpTag (VecReadScalarByteArrayOp IntVec 8 W16) = 916+primOpTag (VecReadScalarByteArrayOp IntVec 4 W32) = 917+primOpTag (VecReadScalarByteArrayOp IntVec 2 W64) = 918+primOpTag (VecReadScalarByteArrayOp IntVec 32 W8) = 919+primOpTag (VecReadScalarByteArrayOp IntVec 16 W16) = 920+primOpTag (VecReadScalarByteArrayOp IntVec 8 W32) = 921+primOpTag (VecReadScalarByteArrayOp IntVec 4 W64) = 922+primOpTag (VecReadScalarByteArrayOp IntVec 64 W8) = 923+primOpTag (VecReadScalarByteArrayOp IntVec 32 W16) = 924+primOpTag (VecReadScalarByteArrayOp IntVec 16 W32) = 925+primOpTag (VecReadScalarByteArrayOp IntVec 8 W64) = 926+primOpTag (VecReadScalarByteArrayOp WordVec 16 W8) = 927+primOpTag (VecReadScalarByteArrayOp WordVec 8 W16) = 928+primOpTag (VecReadScalarByteArrayOp WordVec 4 W32) = 929+primOpTag (VecReadScalarByteArrayOp WordVec 2 W64) = 930+primOpTag (VecReadScalarByteArrayOp WordVec 32 W8) = 931+primOpTag (VecReadScalarByteArrayOp WordVec 16 W16) = 932+primOpTag (VecReadScalarByteArrayOp WordVec 8 W32) = 933+primOpTag (VecReadScalarByteArrayOp WordVec 4 W64) = 934+primOpTag (VecReadScalarByteArrayOp WordVec 64 W8) = 935+primOpTag (VecReadScalarByteArrayOp WordVec 32 W16) = 936+primOpTag (VecReadScalarByteArrayOp WordVec 16 W32) = 937+primOpTag (VecReadScalarByteArrayOp WordVec 8 W64) = 938+primOpTag (VecReadScalarByteArrayOp FloatVec 4 W32) = 939+primOpTag (VecReadScalarByteArrayOp FloatVec 2 W64) = 940+primOpTag (VecReadScalarByteArrayOp FloatVec 8 W32) = 941+primOpTag (VecReadScalarByteArrayOp FloatVec 4 W64) = 942+primOpTag (VecReadScalarByteArrayOp FloatVec 16 W32) = 943+primOpTag (VecReadScalarByteArrayOp FloatVec 8 W64) = 944+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W8) = 945+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W16) = 946+primOpTag (VecWriteScalarByteArrayOp IntVec 4 W32) = 947+primOpTag (VecWriteScalarByteArrayOp IntVec 2 W64) = 948+primOpTag (VecWriteScalarByteArrayOp IntVec 32 W8) = 949+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W16) = 950+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W32) = 951+primOpTag (VecWriteScalarByteArrayOp IntVec 4 W64) = 952+primOpTag (VecWriteScalarByteArrayOp IntVec 64 W8) = 953+primOpTag (VecWriteScalarByteArrayOp IntVec 32 W16) = 954+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W32) = 955+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W64) = 956+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W8) = 957+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W16) = 958+primOpTag (VecWriteScalarByteArrayOp WordVec 4 W32) = 959+primOpTag (VecWriteScalarByteArrayOp WordVec 2 W64) = 960+primOpTag (VecWriteScalarByteArrayOp WordVec 32 W8) = 961+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W16) = 962+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W32) = 963+primOpTag (VecWriteScalarByteArrayOp WordVec 4 W64) = 964+primOpTag (VecWriteScalarByteArrayOp WordVec 64 W8) = 965+primOpTag (VecWriteScalarByteArrayOp WordVec 32 W16) = 966+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W32) = 967+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W64) = 968+primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W32) = 969+primOpTag (VecWriteScalarByteArrayOp FloatVec 2 W64) = 970+primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W32) = 971+primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W64) = 972+primOpTag (VecWriteScalarByteArrayOp FloatVec 16 W32) = 973+primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W64) = 974+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W8) = 975+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W16) = 976+primOpTag (VecIndexScalarOffAddrOp IntVec 4 W32) = 977+primOpTag (VecIndexScalarOffAddrOp IntVec 2 W64) = 978+primOpTag (VecIndexScalarOffAddrOp IntVec 32 W8) = 979+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W16) = 980+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W32) = 981+primOpTag (VecIndexScalarOffAddrOp IntVec 4 W64) = 982+primOpTag (VecIndexScalarOffAddrOp IntVec 64 W8) = 983+primOpTag (VecIndexScalarOffAddrOp IntVec 32 W16) = 984+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W32) = 985+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W64) = 986+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W8) = 987+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W16) = 988+primOpTag (VecIndexScalarOffAddrOp WordVec 4 W32) = 989+primOpTag (VecIndexScalarOffAddrOp WordVec 2 W64) = 990+primOpTag (VecIndexScalarOffAddrOp WordVec 32 W8) = 991+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W16) = 992+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W32) = 993+primOpTag (VecIndexScalarOffAddrOp WordVec 4 W64) = 994+primOpTag (VecIndexScalarOffAddrOp WordVec 64 W8) = 995+primOpTag (VecIndexScalarOffAddrOp WordVec 32 W16) = 996+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W32) = 997+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W64) = 998+primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W32) = 999+primOpTag (VecIndexScalarOffAddrOp FloatVec 2 W64) = 1000+primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W32) = 1001+primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W64) = 1002+primOpTag (VecIndexScalarOffAddrOp FloatVec 16 W32) = 1003+primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W64) = 1004+primOpTag (VecReadScalarOffAddrOp IntVec 16 W8) = 1005+primOpTag (VecReadScalarOffAddrOp IntVec 8 W16) = 1006+primOpTag (VecReadScalarOffAddrOp IntVec 4 W32) = 1007+primOpTag (VecReadScalarOffAddrOp IntVec 2 W64) = 1008+primOpTag (VecReadScalarOffAddrOp IntVec 32 W8) = 1009+primOpTag (VecReadScalarOffAddrOp IntVec 16 W16) = 1010+primOpTag (VecReadScalarOffAddrOp IntVec 8 W32) = 1011+primOpTag (VecReadScalarOffAddrOp IntVec 4 W64) = 1012+primOpTag (VecReadScalarOffAddrOp IntVec 64 W8) = 1013+primOpTag (VecReadScalarOffAddrOp IntVec 32 W16) = 1014+primOpTag (VecReadScalarOffAddrOp IntVec 16 W32) = 1015+primOpTag (VecReadScalarOffAddrOp IntVec 8 W64) = 1016+primOpTag (VecReadScalarOffAddrOp WordVec 16 W8) = 1017+primOpTag (VecReadScalarOffAddrOp WordVec 8 W16) = 1018+primOpTag (VecReadScalarOffAddrOp WordVec 4 W32) = 1019+primOpTag (VecReadScalarOffAddrOp WordVec 2 W64) = 1020+primOpTag (VecReadScalarOffAddrOp WordVec 32 W8) = 1021+primOpTag (VecReadScalarOffAddrOp WordVec 16 W16) = 1022+primOpTag (VecReadScalarOffAddrOp WordVec 8 W32) = 1023+primOpTag (VecReadScalarOffAddrOp WordVec 4 W64) = 1024+primOpTag (VecReadScalarOffAddrOp WordVec 64 W8) = 1025+primOpTag (VecReadScalarOffAddrOp WordVec 32 W16) = 1026+primOpTag (VecReadScalarOffAddrOp WordVec 16 W32) = 1027+primOpTag (VecReadScalarOffAddrOp WordVec 8 W64) = 1028+primOpTag (VecReadScalarOffAddrOp FloatVec 4 W32) = 1029+primOpTag (VecReadScalarOffAddrOp FloatVec 2 W64) = 1030+primOpTag (VecReadScalarOffAddrOp FloatVec 8 W32) = 1031+primOpTag (VecReadScalarOffAddrOp FloatVec 4 W64) = 1032+primOpTag (VecReadScalarOffAddrOp FloatVec 16 W32) = 1033+primOpTag (VecReadScalarOffAddrOp FloatVec 8 W64) = 1034+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W8) = 1035+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W16) = 1036+primOpTag (VecWriteScalarOffAddrOp IntVec 4 W32) = 1037+primOpTag (VecWriteScalarOffAddrOp IntVec 2 W64) = 1038+primOpTag (VecWriteScalarOffAddrOp IntVec 32 W8) = 1039+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W16) = 1040+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W32) = 1041+primOpTag (VecWriteScalarOffAddrOp IntVec 4 W64) = 1042+primOpTag (VecWriteScalarOffAddrOp IntVec 64 W8) = 1043+primOpTag (VecWriteScalarOffAddrOp IntVec 32 W16) = 1044+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W32) = 1045+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W64) = 1046+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W8) = 1047+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W16) = 1048+primOpTag (VecWriteScalarOffAddrOp WordVec 4 W32) = 1049+primOpTag (VecWriteScalarOffAddrOp WordVec 2 W64) = 1050+primOpTag (VecWriteScalarOffAddrOp WordVec 32 W8) = 1051+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W16) = 1052+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W32) = 1053+primOpTag (VecWriteScalarOffAddrOp WordVec 4 W64) = 1054+primOpTag (VecWriteScalarOffAddrOp WordVec 64 W8) = 1055+primOpTag (VecWriteScalarOffAddrOp WordVec 32 W16) = 1056+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W32) = 1057+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W64) = 1058+primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W32) = 1059+primOpTag (VecWriteScalarOffAddrOp FloatVec 2 W64) = 1060+primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W32) = 1061+primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W64) = 1062+primOpTag (VecWriteScalarOffAddrOp FloatVec 16 W32) = 1063+primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W64) = 1064+primOpTag PrefetchByteArrayOp3 = 1065+primOpTag PrefetchMutableByteArrayOp3 = 1066+primOpTag PrefetchAddrOp3 = 1067+primOpTag PrefetchValueOp3 = 1068+primOpTag PrefetchByteArrayOp2 = 1069+primOpTag PrefetchMutableByteArrayOp2 = 1070+primOpTag PrefetchAddrOp2 = 1071+primOpTag PrefetchValueOp2 = 1072+primOpTag PrefetchByteArrayOp1 = 1073+primOpTag PrefetchMutableByteArrayOp1 = 1074+primOpTag PrefetchAddrOp1 = 1075+primOpTag PrefetchValueOp1 = 1076+primOpTag PrefetchByteArrayOp0 = 1077+primOpTag PrefetchMutableByteArrayOp0 = 1078+primOpTag PrefetchAddrOp0 = 1079+primOpTag PrefetchValueOp0 = 1080
backpack/BkpSyn.hs view
@@ -17,8 +17,9 @@ LRenaming, Renaming(..), ) where +import GhcPrelude+ import HsSyn-import RdrName import SrcLoc import Outputable import Module@@ -61,7 +62,7 @@ -- or an include. data HsDeclType = ModuleD | SignatureD data HsUnitDecl n- = DeclD HsDeclType (Located ModuleName) (Maybe (Located (HsModule RdrName)))+ = DeclD HsDeclType (Located ModuleName) (Maybe (Located (HsModule GhcPs))) | IncludeD (IncludeDecl n) type LHsUnitDecl n = Located (HsUnitDecl n)
backpack/DriverBkp.hs view
@@ -18,6 +18,8 @@ #include "HsVersions.h" +import GhcPrelude+ -- In a separate module because it hooks into the parser. import BkpSyn @@ -80,7 +82,7 @@ buf <- liftIO $ hGetStringBuffer src_filename let loc = mkRealSrcLoc (mkFastString src_filename) 1 1 -- TODO: not great case unP parseBackpack (mkPState dflags buf loc) of- PFailed span err -> do+ PFailed _ span err -> do liftIO $ throwOneError (mkPlainErrMsg dflags span err) POk _ pkgname_bkp -> do -- OK, so we have an LHsUnit PackageName, but we want an@@ -155,6 +157,7 @@ -- turn on interface writing. However, if the user also -- explicitly passed in `-fno-code`, we DON'T want to write -- interfaces unless the user also asked for `-fwrite-interface`.+ -- See Note [-fno-code mode] (case session_type of -- Make sure to write interfaces when we are type-checking -- indefinite packages.@@ -287,7 +290,8 @@ let hi_dir = expectJust (panic "hiDir Backpack") $ hiDir dflags export_mod ms = (ms_mod_name ms, ms_mod ms) -- Export everything!- mods = [ export_mod ms | ms <- mod_graph, ms_hsc_src ms == HsSrcFile ]+ mods = [ export_mod ms | ms <- mgModSummaries mod_graph+ , ms_hsc_src ms == HsSrcFile ] -- Compile relevant only hsc_env <- getSession@@ -659,7 +663,7 @@ else fmap Just $ summariseRequirement pn mod_name -- 3. Return the kaboodle- return (nodes ++ req_nodes)+ return $ mkModuleGraph $ nodes ++ req_nodes summariseRequirement :: PackageName -> ModuleName -> BkpM ModSummary summariseRequirement pn mod_name = do@@ -708,7 +712,7 @@ summariseDecl :: PackageName -> HscSource -> Located ModuleName- -> Maybe (Located (HsModule RdrName))+ -> Maybe (Located (HsModule GhcPs)) -> BkpM ModSummary summariseDecl pn hsc_src (L _ modname) (Just hsmod) = hsModuleToModSummary pn hsc_src modname hsmod summariseDecl _pn hsc_src lmodname@(L loc modname) Nothing@@ -735,7 +739,7 @@ hsModuleToModSummary :: PackageName -> HscSource -> ModuleName- -> Located (HsModule RdrName)+ -> Located (HsModule GhcPs) -> BkpM ModSummary hsModuleToModSummary pn hsc_src modname hsmod = do
backpack/NameShape.hs view
@@ -12,6 +12,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Outputable import HscTypes import Module@@ -159,7 +161,7 @@ -- | Substitution on @{A.T}@. We enforce the invariant that the -- 'nameModule' of keys of this map have 'moduleUnitId' @hole@ -- (meaning that if we have a hole substitution, the keys of the map--- are never affected.) Alternately, this is isomorphic to+-- are never affected.) Alternatively, this is isomorphic to -- @Map ('ModuleName', 'OccName') 'Name'@. type ShNameSubst = NameEnv Name
backpack/RnModIface.hs view
@@ -15,6 +15,8 @@ #include "HsVersions.h" +import GhcPrelude+ import SrcLoc import Outputable import HscTypes@@ -422,11 +424,13 @@ binders <- mapM rnIfaceTyConBinder (ifBinders d) ctxt <- mapM rnIfaceType (ifCtxt d) cons <- rnIfaceConDecls (ifCons d)+ res_kind <- rnIfaceType (ifResKind d) parent <- rnIfaceTyConParent (ifParent d) return d { ifName = name , ifBinders = binders , ifCtxt = ctxt , ifCons = cons+ , ifResKind = res_kind , ifParent = parent } rnIfaceDecl d@IfaceSynonym{} = do@@ -521,7 +525,8 @@ rnIfaceConDecl :: Rename IfaceConDecl rnIfaceConDecl d = do con_name <- rnIfaceGlobal (ifConName d)- con_ex_tvs <- mapM rnIfaceForAllBndr (ifConExTvs d)+ con_ex_tvs <- mapM rnIfaceTvBndr (ifConExTvs d)+ con_user_tvbs <- mapM rnIfaceForAllBndr (ifConUserTvBinders d) let rnIfConEqSpec (n,t) = (,) n <$> rnIfaceType t con_eq_spec <- mapM rnIfConEqSpec (ifConEqSpec d) con_ctxt <- mapM rnIfaceType (ifConCtxt d)@@ -532,6 +537,7 @@ con_stricts <- mapM rnIfaceBang (ifConStricts d) return d { ifConName = con_name , ifConExTvs = con_ex_tvs+ , ifConUserTvBinders = con_user_tvbs , ifConEqSpec = con_eq_spec , ifConCtxt = con_ctxt , ifConArgTys = con_arg_tys@@ -646,7 +652,9 @@ = IfaceAppCo <$> rnIfaceCo co1 <*> rnIfaceCo co2 rnIfaceCo (IfaceForAllCo bndr co1 co2) = IfaceForAllCo <$> rnIfaceTvBndr bndr <*> rnIfaceCo co1 <*> rnIfaceCo co2+rnIfaceCo (IfaceFreeCoVar c) = pure (IfaceFreeCoVar c) rnIfaceCo (IfaceCoVarCo lcl) = IfaceCoVarCo <$> pure lcl+rnIfaceCo (IfaceHoleCo lcl) = IfaceHoleCo <$> pure lcl rnIfaceCo (IfaceAxiomInstCo n i cs) = IfaceAxiomInstCo <$> rnIfaceGlobal n <*> pure i <*> mapM rnIfaceCo cs rnIfaceCo (IfaceUnivCo s r t1 t2)
basicTypes/Avail.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveDataTypeable #-} -- -- (c) The University of Glasgow --@@ -25,6 +26,8 @@ ) where +import GhcPrelude+ import Name import NameEnv import NameSet@@ -35,6 +38,7 @@ import Outputable import Util +import Data.Data ( Data ) import Data.List ( find ) import Data.Function @@ -59,7 +63,7 @@ -- to be in scope, it must be -- *first* in this list. Thus, -- typically: @AvailTC Eq [Eq, ==, \/=]@- deriving( Eq )+ deriving( Eq, Data ) -- Equality used when deciding if the -- interface has changed
basicTypes/BasicTypes.hs view
@@ -85,7 +85,7 @@ isNeverActive, isAlwaysActive, isEarlyActive, RuleMatchInfo(..), isConLike, isFunLike,- InlineSpec(..), isEmptyInlineSpec,+ InlineSpec(..), noUserInlineSpec, InlinePragma(..), defaultInlinePragma, alwaysInlinePragma, neverInlinePragma, dfunInlinePragma, isDefaultInlinePragma,@@ -97,7 +97,10 @@ SuccessFlag(..), succeeded, failed, successIf, - FractionalLit(..), negateFractionalLit, integralFractionalLit,+ IntegralLit(..), FractionalLit(..),+ negateIntegralLit, negateFractionalLit,+ mkIntegralLit, mkFractionalLit,+ integralFractionalLit, SourceText(..), pprWithSourceText, @@ -106,6 +109,8 @@ SpliceExplicitFlag(..) ) where +import GhcPrelude+ import FastString import Outputable import SrcLoc ( Located,unLoc )@@ -697,13 +702,68 @@ | FunPrec -- Function args; no parens for tycon apps | TyOpPrec -- Infix operator | TyConPrec -- Tycon args; no parens for atomic- deriving( Eq, Ord ) +instance Eq TyPrec where+ (==) a b = case compare a b of+ EQ -> True+ _ -> False++instance Ord TyPrec where+ compare TopPrec TopPrec = EQ+ compare TopPrec _ = LT++ compare FunPrec TopPrec = GT+ compare FunPrec FunPrec = EQ+ compare FunPrec TyOpPrec = EQ -- See Note [Type operator precedence]+ compare FunPrec TyConPrec = LT++ compare TyOpPrec TopPrec = GT+ compare TyOpPrec FunPrec = EQ -- See Note [Type operator precedence]+ compare TyOpPrec TyOpPrec = EQ+ compare TyOpPrec TyConPrec = LT++ compare TyConPrec TyConPrec = EQ+ compare TyConPrec _ = GT+ maybeParen :: TyPrec -> TyPrec -> SDoc -> SDoc maybeParen ctxt_prec inner_prec pretty | ctxt_prec < inner_prec = pretty | otherwise = parens pretty +{- Note [Precedence in types]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Many pretty-printing functions have type+ ppr_ty :: TyPrec -> Type -> SDoc++The TyPrec gives the binding strength of the context. For example, in+ T ty1 ty2+we will pretty-print 'ty1' and 'ty2' with the call+ (ppr_ty TyConPrec ty)+to indicate that the context is that of an argument of a TyConApp.++We use this consistently for Type and HsType.++Note [Type operator precedence]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We don't keep the fixity of type operators in the operator. So the+pretty printer follows the following precedence order:++ TyConPrec Type constructor application+ TyOpPrec/FunPrec Operator application and function arrow++We have FunPrec and TyOpPrec to represent the precedence of function+arrow and type operators respectively, but currently we implement+FunPred == TyOpPrec, so that we don't distinguish the two. Reason:+it's hard to parse a type like+ a ~ b => c * d -> e - f++By treating TyOpPrec = FunPrec we end up with more parens+ (a ~ b) => (c * d) -> (e - f)++But the two are different constructors of TyPrec so we could make+(->) bind more or less tightly if we wanted.+-}+ {- ************************************************************************ * *@@ -731,9 +791,8 @@ tupleParens BoxedTuple p = parens p tupleParens UnboxedTuple p = text "(#" <+> p <+> ptext (sLit "#)") tupleParens ConstraintTuple p -- In debug-style write (% Eq a, Ord b %)- = sdocWithPprDebug $ \dbg -> if dbg- then text "(%" <+> p <+> ptext (sLit "%)")- else parens p+ = ifPprDebug (text "(%" <+> p <+> ptext (sLit "%)"))+ (parens p) {- ************************************************************************@@ -1164,8 +1223,8 @@ = Inline | Inlinable | NoInline- | EmptyInlineSpec -- Used in a place-holder InlinePragma in SpecPrag or IdInfo,- -- where there isn't any real inline pragma at all+ | NoUserInline -- Used when the pragma did not come from the user,+ -- e.g. in `defaultInlinePragma` or when created by CSE deriving( Eq, Data, Show ) -- Show needed for Lexer.x @@ -1175,7 +1234,7 @@ the source program. If you write nothing at all, you get defaultInlinePragma:- inl_inline = EmptyInlineSpec+ inl_inline = NoUserInline inl_act = AlwaysActive inl_rule = FunLike @@ -1248,16 +1307,16 @@ isFunLike FunLike = True isFunLike _ = False -isEmptyInlineSpec :: InlineSpec -> Bool-isEmptyInlineSpec EmptyInlineSpec = True-isEmptyInlineSpec _ = False+noUserInlineSpec :: InlineSpec -> Bool+noUserInlineSpec NoUserInline = True+noUserInlineSpec _ = False defaultInlinePragma, alwaysInlinePragma, neverInlinePragma, dfunInlinePragma :: InlinePragma defaultInlinePragma = InlinePragma { inl_src = SourceText "{-# INLINE" , inl_act = AlwaysActive , inl_rule = FunLike- , inl_inline = EmptyInlineSpec+ , inl_inline = NoUserInline , inl_sat = Nothing } alwaysInlinePragma = defaultInlinePragma { inl_inline = Inline }@@ -1277,7 +1336,7 @@ isDefaultInlinePragma (InlinePragma { inl_act = activation , inl_rule = match_info , inl_inline = inline })- = isEmptyInlineSpec inline && isAlwaysActive activation && isFunLike match_info+ = noUserInlineSpec inline && isAlwaysActive activation && isFunLike match_info isInlinePragma :: InlinePragma -> Bool isInlinePragma prag = case inl_inline prag of@@ -1322,10 +1381,10 @@ ppr FunLike = text "FUNLIKE" instance Outputable InlineSpec where- ppr Inline = text "INLINE"- ppr NoInline = text "NOINLINE"- ppr Inlinable = text "INLINABLE"- ppr EmptyInlineSpec = empty+ ppr Inline = text "INLINE"+ ppr NoInline = text "NOINLINE"+ ppr Inlinable = text "INLINABLE"+ ppr NoUserInline = text "NOUSERINLINE" -- what is better? instance Outputable InlinePragma where ppr = pprInline@@ -1404,6 +1463,30 @@ isEarlyActive (ActiveBefore {}) = True isEarlyActive _ = False +-- | Integral Literal+--+-- Used (instead of Integer) to represent negative zegative zero which is+-- required for NegativeLiterals extension to correctly parse `-0::Double`+-- as negative zero. See also #13211.+data IntegralLit+ = IL { il_text :: SourceText+ , il_neg :: Bool -- See Note [Negative zero]+ , il_value :: Integer+ }+ deriving (Data, Show)++mkIntegralLit :: Integral a => a -> IntegralLit+mkIntegralLit i = IL { il_text = SourceText (show (fromIntegral i :: Int))+ , il_neg = i < 0+ , il_value = toInteger i }++negateIntegralLit :: IntegralLit -> IntegralLit+negateIntegralLit (IL text neg value)+ = case text of+ SourceText ('-':src) -> IL (SourceText src) False (negate value)+ SourceText src -> IL (SourceText ('-':src)) True (negate value)+ NoSourceText -> IL NoSourceText (not neg) (negate value)+ -- | Fractional Literal -- -- Used (instead of Rational) to represent exactly the floating point literal that we@@ -1411,22 +1494,43 @@ -- the user wrote, which is important e.g. for floating point numbers that can't represented -- as Doubles (we used to via Double for pretty-printing). See also #2245. data FractionalLit- = FL { fl_text :: String -- How the value was written in the source+ = FL { fl_text :: SourceText -- How the value was written in the source+ , fl_neg :: Bool -- See Note [Negative zero] , fl_value :: Rational -- Numeric value of the literal } deriving (Data, Show) -- The Show instance is required for the derived Lexer.x:Token instance when DEBUG is on +mkFractionalLit :: Real a => a -> FractionalLit+mkFractionalLit r = FL { fl_text = SourceText (show (realToFrac r::Double))+ , fl_neg = r < 0+ , fl_value = toRational r }+ negateFractionalLit :: FractionalLit -> FractionalLit-negateFractionalLit (FL { fl_text = '-':text, fl_value = value }) = FL { fl_text = text, fl_value = negate value }-negateFractionalLit (FL { fl_text = text, fl_value = value }) = FL { fl_text = '-':text, fl_value = negate value }+negateFractionalLit (FL text neg value)+ = case text of+ SourceText ('-':src) -> FL (SourceText src) False value+ SourceText src -> FL (SourceText ('-':src)) True value+ NoSourceText -> FL NoSourceText (not neg) (negate value) -integralFractionalLit :: Integer -> FractionalLit-integralFractionalLit i = FL { fl_text = show i, fl_value = fromInteger i }+integralFractionalLit :: Bool -> Integer -> FractionalLit+integralFractionalLit neg i = FL { fl_text = SourceText (show i),+ fl_neg = neg,+ fl_value = fromInteger i } -- Comparison operations are needed when grouping literals -- for compiling pattern-matching (module MatchLit) +instance Eq IntegralLit where+ (==) = (==) `on` il_value++instance Ord IntegralLit where+ compare = compare `on` il_value++instance Outputable IntegralLit where+ ppr (IL (SourceText src) _ _) = text src+ ppr (IL NoSourceText _ value) = text (show value)+ instance Eq FractionalLit where (==) = (==) `on` fl_value @@ -1434,7 +1538,7 @@ compare = compare `on` fl_value instance Outputable FractionalLit where- ppr = text . fl_text+ ppr f = pprWithSourceText (fl_text f) (rational (fl_value f)) {- ************************************************************************
basicTypes/ConLike.hs view
@@ -26,6 +26,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DataCon import PatSyn import Outputable
basicTypes/DataCon.hs view
@@ -28,11 +28,11 @@ -- ** Type deconstruction dataConRepType, dataConSig, dataConInstSig, dataConFullSig,- dataConName, dataConIdentity, dataConTag, dataConTyCon,- dataConOrigTyCon, dataConUserType,- dataConUnivTyVars, dataConUnivTyVarBinders,- dataConExTyVars, dataConExTyVarBinders,- dataConAllTyVars,+ dataConName, dataConIdentity, dataConTag, dataConTagZ,+ dataConTyCon, dataConOrigTyCon,+ dataConUserType,+ dataConUnivTyVars, dataConExTyVars, dataConUnivAndExTyVars,+ dataConUserTyVars, dataConUserTyVarBinders, dataConEqSpec, dataConTheta, dataConStupidTheta, dataConInstArgTys, dataConOrigArgTys, dataConOrigResTy,@@ -51,6 +51,7 @@ isNullarySrcDataCon, isNullaryRepDataCon, isTupleDataCon, isUnboxedTupleCon, isUnboxedSumCon, isVanillaDataCon, classDataCon, dataConCannotMatch,+ dataConUserTyVarsArePermuted, isBanged, isMarkedStrict, eqHsBang, isSrcStrict, isSrcUnpacked, specialPromotedDc, isLegacyPromotableDataCon, isLegacyPromotableTyCon, @@ -60,6 +61,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} MkId( DataConBoxer ) import Type import ForeignCall ( CType )@@ -85,6 +88,7 @@ import Data.Char import Data.Word import Data.List( mapAccumL, find )+import qualified Data.Set as Set {- Data constructor representation@@ -232,7 +236,7 @@ it separately in the type checker on occurrences of a constructor, either in an expression or in a pattern. - [May 2003: actually I think this decision could evasily be+ [May 2003: actually I think this decision could easily be reversed now, and probably should be. Generics could be disabled for types with a stupid context; record updates now (H98) needs the context too; etc. It's an unforced change, so@@ -274,27 +278,37 @@ -- Running example: -- -- *** As declared by the user- -- data T a where- -- MkT :: forall x y. (x~y,Ord x) => x -> y -> T (x,y)+ -- data T a b c where+ -- MkT :: forall c y x b. (x~y,Ord x) => x -> y -> T (x,y) b c -- *** As represented internally- -- data T a where- -- MkT :: forall a. forall x y. (a~(x,y),x~y,Ord x) => x -> y -> T a+ -- data T a b c where+ -- MkT :: forall a b c. forall x y. (a~(x,y),x~y,Ord x)+ -- => x -> y -> T a b c -- -- The next six fields express the type of the constructor, in pieces -- e.g. --- -- dcUnivTyVars = [a]- -- dcExTyVars = [x,y]- -- dcEqSpec = [a~(x,y)]- -- dcOtherTheta = [x~y, Ord x]- -- dcOrigArgTys = [x,y]- -- dcRepTyCon = T+ -- dcUnivTyVars = [a,b,c]+ -- dcExTyVars = [x,y]+ -- dcUserTyVarBinders = [c,y,x,b]+ -- dcEqSpec = [a~(x,y)]+ -- dcOtherTheta = [x~y, Ord x]+ -- dcOrigArgTys = [x,y]+ -- dcRepTyCon = T -- In general, the dcUnivTyVars are NOT NECESSARILY THE SAME AS THE TYVARS -- FOR THE PARENT TyCon. (This is a change (Oct05): previously, vanilla -- datacons guaranteed to have the same type variables as their parent TyCon,- -- but that seems ugly.)+ -- but that seems ugly.) They can be different in the case where a GADT+ -- constructor uses different names for the universal tyvars than does+ -- the tycon. For example:+ --+ -- data H a where+ -- MkH :: b -> H b+ --+ -- Here, the tyConTyVars of H will be [a], but the dcUnivTyVars of MkH+ -- will be [b]. dcVanilla :: Bool, -- True <=> This is a vanilla Haskell 98 data constructor -- Its type is of form@@ -309,14 +323,23 @@ -- Universally-quantified type vars [a,b,c] -- INVARIANT: length matches arity of the dcRepTyCon -- INVARIANT: result type of data con worker is exactly (T a b c)- dcUnivTyVars :: [TyVarBinder],+ -- COROLLARY: The dcUnivTyVars are always in one-to-one correspondence with+ -- the tyConTyVars of the parent TyCon+ dcUnivTyVars :: [TyVar], -- Existentially-quantified type vars [x,y]- dcExTyVars :: [TyVarBinder],+ dcExTyVars :: [TyVar], -- INVARIANT: the UnivTyVars and ExTyVars all have distinct OccNames -- Reason: less confusing, and easier to generate IfaceSyn + -- The type vars in the order the user wrote them [c,y,x,b]+ -- INVARIANT: the set of tyvars in dcUserTyVarBinders is exactly the+ -- set of dcExTyVars unioned with the set of dcUnivTyVars+ -- whose tyvars do not appear in dcEqSpec+ -- See Note [DataCon user type variable binders]+ dcUserTyVarBinders :: [TyVarBinder],+ dcEqSpec :: [EqSpec], -- Equalities derived from the result type, -- _as written by the programmer_ @@ -424,9 +447,12 @@ Why do we need the TyVarBinders, rather than just the TyVars? So that we can construct the right type for the DataCon with its foralls-attributed the correce visiblity. That in turn governs whether you+attributed the correct visibility. That in turn governs whether you can use visible type application at a call of the data constructor. +See also [DataCon user type variable binders] for an extended discussion on the+order in which TyVarBinders appear in a DataCon.+ Note [DataCon arities] ~~~~~~~~~~~~~~~~~~~~~~ dcSourceArity does not take constraints into account,@@ -434,6 +460,83 @@ MkT :: Ord a => a -> T a dcSourceArity = 1 dcRepArity = 2++Note [DataCon user type variable binders]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In System FC, data constructor type signatures always quantify over all of+their universal type variables, followed by their existential type variables.+Normally, this isn't a problem, as most datatypes naturally quantify their type+variables in this order anyway. For example:++ data T a b = forall c. MkT b c++Here, we have `MkT :: forall {k} (a :: k) (b :: *) (c :: *). b -> c -> T a b`,+where k, a, and b are universal and c is existential. (The inferred variable k+isn't available for TypeApplications, hence why it's in braces.) This is a+perfectly reasonable order to use, as the syntax of H98-style datatypes+(+ ExistentialQuantification) suggests it.++Things become more complicated when GADT syntax enters the picture. Consider+this example:++ data X a where+ MkX :: forall b a. b -> Proxy a -> X a++If we adopt the earlier approach of quantifying all the universal variables+followed by all the existential ones, GHC would come up with this type+signature for MkX:++ MkX :: forall {k} (a :: k) (b :: *). b -> Proxy a -> X a++But this is not what we want at all! After all, if a user were to use+TypeApplications on MkX, they would expect to instantiate `b` before `a`,+as that's the order in which they were written in the `forall`. (See #11721.)+Instead, we'd like GHC to come up with this type signature:++ MkX :: forall {k} (b :: *) (a :: k). b -> Proxy a -> X a++In fact, even if we left off the explicit forall:++ data X a where+ MkX :: b -> Proxy a -> X a++Then a user should still expect `b` to be quantified before `a`, since+according to the rules of TypeApplications, in the absence of `forall` GHC+performs a stable topological sort on the type variables in the user-written+type signature, which would place `b` before `a`.++But as noted above, enacting this behavior is not entirely trivial, as System+FC demands the variables go in universal-then-existential order under the hood.+Our solution is thus to equip DataCon with two different sets of type+variables:++* dcUnivTyVars and dcExTyVars, for the universal and existential type+ variables, respectively. Their order is irrelevant for the purposes of+ TypeApplications, and as a consequence, they do not come equipped with+ visibilities (that is, they are TyVars instead of TyVarBinders).+* dcUserTyVarBinders, for the type variables binders in the order in which they+ originally arose in the user-written type signature. Their order *does*+ matter for TypeApplications, so they are full TyVarBinders, complete+ with visibilities.++This encoding has some redundancy. The set of tyvars in dcUserTyVarBinders+consists precisely of:++* The set of tyvars in dcUnivTyVars whose type variables do not appear in+ dcEqSpec, unioned with:+* The set of tyvars in dcExTyVars++The word "set" is used above because the order in which the tyvars+appear in dcUserTyVarBinders can be completely different from the order in+dcUnivTyVars or dcExTyVars. That is, the tyvars in dcUserTyVarBinders are a+permutation of (dcExTyVars + a subset of dcUnivTyVars). But aside from the+ordering, they in fact share the same type variables (with the same Uniques).+We sometimes refer to this as "the dcUserTyVarBinders invariant".++dcUserTyVarBinders, as the name suggests, is the one that users will see most+of the time. It's used when computing the type signature of a data constructor+(see dataConUserType), and as a result, it's what matters from a+TypeApplications perspective. -} -- | Data Constructor Representation@@ -504,7 +607,7 @@ -- Bangs of data constructor arguments as generated by the compiler -- after consulting HsSrcBang, flags, etc. data HsImplBang- = HsLazy -- ^ Lazy field+ = HsLazy -- ^ Lazy field, or one with an unlifted type | HsStrict -- ^ Strict but not unpacked field | HsUnpack (Maybe Coercion) -- ^ Strict and unpacked field@@ -565,13 +668,12 @@ where tv' = getTyVar "substEqSpec" (substTyVar subst tv) --- | Filter out any TyBinders mentioned in an EqSpec-filterEqSpec :: [EqSpec] -> [TyVarBinder] -> [TyVarBinder]+-- | Filter out any 'TyVar's mentioned in an 'EqSpec'.+filterEqSpec :: [EqSpec] -> [TyVar] -> [TyVar] filterEqSpec eq_spec = filter not_in_eq_spec where- not_in_eq_spec bndr = let var = binderVar bndr in- all (not . (== var) . eqSpecTyVar) eq_spec+ not_in_eq_spec var = all (not . (== var) . eqSpecTyVar) eq_spec instance Outputable EqSpec where ppr (EqSpec tv ty) = ppr (tv, ty)@@ -749,9 +851,11 @@ -> [HsSrcBang] -- ^ Strictness/unpack annotations, from user -> [FieldLabel] -- ^ Field labels for the constructor, -- if it is a record, otherwise empty- -> [TyVarBinder] -- ^ Universals. See Note [TyVarBinders in DataCons]- -> [TyVarBinder] -- ^ Existentials.- -- (These last two must be Named and Inferred/Specified)+ -> [TyVar] -- ^ Universals.+ -> [TyVar] -- ^ Existentials.+ -> [TyVarBinder] -- ^ User-written 'TyVarBinder's.+ -- These must be Inferred/Specified.+ -- See @Note [TyVarBinders in DataCons]@ -> [EqSpec] -- ^ GADT equalities -> ThetaType -- ^ Theta-type occuring before the arguments proper -> [Type] -- ^ Original argument types@@ -768,25 +872,35 @@ mkDataCon name declared_infix prom_info arg_stricts -- Must match orig_arg_tys 1-1 fields- univ_tvs ex_tvs+ univ_tvs ex_tvs user_tvbs eq_spec theta orig_arg_tys orig_res_ty rep_info rep_tycon stupid_theta work_id rep--- Warning: mkDataCon is not a good place to check invariants.+-- Warning: mkDataCon is not a good place to check certain invariants. -- If the programmer writes the wrong result type in the decl, thus: -- data T a where { MkT :: S } -- then it's possible that the univ_tvs may hit an assertion failure -- if you pull on univ_tvs. This case is checked by checkValidDataCon,--- so the error is detected properly... it's just that asaertions here+-- so the error is detected properly... it's just that assertions here -- are a little dodgy. = con where is_vanilla = null ex_tvs && null eq_spec && null theta+ -- Check the dcUserTyVarBinders invariant+ -- (see Note [DataCon user type variable binders])+ user_tvbs_invariant =+ Set.fromList (filterEqSpec eq_spec univ_tvs ++ ex_tvs)+ == Set.fromList (binderVars user_tvbs)+ user_tvbs' =+ ASSERT2( user_tvbs_invariant+ , ppr univ_tvs $$ ppr ex_tvs $$ ppr user_tvbs )+ user_tvbs con = MkData {dcName = name, dcUnique = nameUnique name, dcVanilla = is_vanilla, dcInfix = declared_infix, dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs,+ dcUserTyVarBinders = user_tvbs', dcEqSpec = eq_spec, dcOtherTheta = theta, dcStupidTheta = stupid_theta,@@ -807,13 +921,20 @@ tag = assoc "mkDataCon" (tyConDataCons rep_tycon `zip` [fIRST_TAG..]) con rep_arg_tys = dataConRepArgTys con - rep_ty = mkForAllTys univ_tvs $ mkForAllTys ex_tvs $- mkFunTys rep_arg_tys $- mkTyConApp rep_tycon (mkTyVarTys (binderVars univ_tvs))+ rep_ty =+ case rep of+ -- If the DataCon has no wrapper, then the worker's type *is* the+ -- user-facing type, so we can simply use dataConUserType.+ NoDataConRep -> dataConUserType con+ -- If the DataCon has a wrapper, then the worker's type is never seen+ -- by the user. The visibilities we pick do not matter here.+ DCR{} -> mkInvForAllTys univ_tvs $ mkInvForAllTys ex_tvs $+ mkFunTys rep_arg_tys $+ mkTyConApp rep_tycon (mkTyVarTys univ_tvs) -- See Note [Promoted data constructors] in TyCon prom_tv_bndrs = [ mkNamedTyConBinder vis tv- | TvBndr tv vis <- filterEqSpec eq_spec univ_tvs ++ ex_tvs ]+ | TvBndr tv vis <- user_tvbs' ] prom_arg_bndrs = mkCleanAnonTyConBinders prom_tv_bndrs (theta ++ orig_arg_tys) prom_res_kind = orig_res_ty@@ -861,6 +982,9 @@ dataConTag :: DataCon -> ConTag dataConTag = dcTag +dataConTagZ :: DataCon -> ConTagZ+dataConTagZ con = dataConTag con - fIRST_TAG+ -- | The type constructor that we are building via this data constructor dataConTyCon :: DataCon -> TyCon dataConTyCon = dcRepTyCon@@ -884,25 +1008,28 @@ -- | The universally-quantified type variables of the constructor dataConUnivTyVars :: DataCon -> [TyVar]-dataConUnivTyVars (MkData { dcUnivTyVars = tvbs }) = binderVars tvbs---- | 'TyBinder's for the universally-quantified type variables-dataConUnivTyVarBinders :: DataCon -> [TyVarBinder]-dataConUnivTyVarBinders = dcUnivTyVars+dataConUnivTyVars (MkData { dcUnivTyVars = tvbs }) = tvbs -- | The existentially-quantified type variables of the constructor dataConExTyVars :: DataCon -> [TyVar]-dataConExTyVars (MkData { dcExTyVars = tvbs }) = binderVars tvbs+dataConExTyVars (MkData { dcExTyVars = tvbs }) = tvbs --- | 'TyBinder's for the existentially-quantified type variables-dataConExTyVarBinders :: DataCon -> [TyVarBinder]-dataConExTyVarBinders = dcExTyVars+-- | Both the universal and existential type variables of the constructor+dataConUnivAndExTyVars :: DataCon -> [TyVar]+dataConUnivAndExTyVars (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs })+ = univ_tvs ++ ex_tvs --- | Both the universal and existentiatial type variables of the constructor-dataConAllTyVars :: DataCon -> [TyVar]-dataConAllTyVars (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs })- = binderVars (univ_tvs ++ ex_tvs)+-- See Note [DataCon user type variable binders]+-- | The type variables of the constructor, in the order the user wrote them+dataConUserTyVars :: DataCon -> [TyVar]+dataConUserTyVars (MkData { dcUserTyVarBinders = tvbs }) = binderVars tvbs +-- See Note [DataCon user type variable binders]+-- | 'TyVarBinder's for the type variables of the constructor, in the order the+-- user wrote them+dataConUserTyVarBinders :: DataCon -> [TyVarBinder]+dataConUserTyVarBinders = dcUserTyVarBinders+ -- | Equalities derived from the result type of the data constructor, as written -- by the programmer in any GADT declaration. This includes *all* GADT-like -- equalities, including those written in by hand by the programmer.@@ -1031,7 +1158,7 @@ -- | The \"signature\" of the 'DataCon' returns, in order: ----- 1) The result of 'dataConAllTyVars',+-- 1) The result of 'dataConUnivAndExTyVars', -- -- 2) All the 'ThetaType's relating to the 'DataCon' (coercion, dictionary, implicit -- parameter - whatever)@@ -1041,14 +1168,14 @@ -- 4) The /original/ result type of the 'DataCon' dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type) dataConSig con@(MkData {dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})- = (dataConAllTyVars con, dataConTheta con, arg_tys, res_ty)+ = (dataConUnivAndExTyVars con, dataConTheta con, arg_tys, res_ty) dataConInstSig :: DataCon -> [Type] -- Instantiate the *universal* tyvars with these types -> ([TyVar], ThetaType, [Type]) -- Return instantiated existentials -- theta and arg tys--- ^ Instantantiate the universal tyvars of a data con,+-- ^ Instantiate the universal tyvars of a data con, -- returning the instantiated existentials, constraints, and args dataConInstSig (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs , dcEqSpec = eq_spec, dcOtherTheta = theta@@ -1058,9 +1185,8 @@ , substTheta subst (eqSpecPreds eq_spec ++ theta) , substTys subst arg_tys) where- univ_subst = zipTvSubst (binderVars univ_tvs) univ_tys- (subst, ex_tvs') = mapAccumL Type.substTyVarBndr univ_subst $- binderVars ex_tvs+ univ_subst = zipTvSubst univ_tvs univ_tys+ (subst, ex_tvs') = mapAccumL Type.substTyVarBndr univ_subst ex_tvs -- | The \"full signature\" of the 'DataCon' returns, in order:@@ -1082,7 +1208,7 @@ dataConFullSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec, dcOtherTheta = theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})- = (binderVars univ_tvs, binderVars ex_tvs, eq_spec, theta, arg_tys, res_ty)+ = (univ_tvs, ex_tvs, eq_spec, theta, arg_tys, res_ty) dataConOrigResTy :: DataCon -> Type dataConOrigResTy dc = dcOrigResTy dc@@ -1103,14 +1229,15 @@ -- -- > T :: forall a c. forall b. (c~[a]) => a -> b -> T c --+-- The type variables are quantified in the order that the user wrote them.+-- See @Note [DataCon user type variable binders]@.+-- -- NB: If the constructor is part of a data instance, the result type -- mentions the family tycon, not the internal one.-dataConUserType (MkData { dcUnivTyVars = univ_tvs,- dcExTyVars = ex_tvs, dcEqSpec = eq_spec,+dataConUserType (MkData { dcUserTyVarBinders = user_tvbs, dcOtherTheta = theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty })- = mkForAllTys (filterEqSpec eq_spec univ_tvs) $- mkForAllTys ex_tvs $+ = mkForAllTys user_tvbs $ mkFunTys theta $ mkFunTys arg_tys $ res_ty@@ -1126,10 +1253,10 @@ -> [Type] dataConInstArgTys dc@(MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs}) inst_tys- = ASSERT2( length univ_tvs == length inst_tys+ = ASSERT2( univ_tvs `equalLength` inst_tys , text "dataConInstArgTys" <+> ppr dc $$ ppr univ_tvs $$ ppr inst_tys) ASSERT2( null ex_tvs, ppr dc )- map (substTyWith (binderVars univ_tvs) inst_tys) (dataConRepArgTys dc)+ map (substTyWith univ_tvs inst_tys) (dataConRepArgTys dc) -- | Returns just the instantiated /value/ argument types of a 'DataCon', -- (excluding dictionary args)@@ -1143,11 +1270,11 @@ dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys, dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs}) inst_tys- = ASSERT2( length tyvars == length inst_tys+ = ASSERT2( tyvars `equalLength` inst_tys , text "dataConInstOrigArgTys" <+> ppr dc $$ ppr tyvars $$ ppr inst_tys ) map (substTyWith tyvars inst_tys) arg_tys where- tyvars = binderVars (univ_tvs ++ ex_tvs)+ tyvars = univ_tvs ++ ex_tvs -- | Returns the argument types of the wrapper, excluding all dictionary arguments -- and without substituting for any type variables@@ -1236,6 +1363,23 @@ ClassPred eq [_, ty1, ty2] | eq `hasKey` eqTyConKey -> [(ty1, ty2)] _ -> []++-- | Were the type variables of the data con written in a different order+-- than the regular order (universal tyvars followed by existential tyvars)?+--+-- This is not a cheap test, so we minimize its use in GHC as much as possible.+-- Currently, its only call site in the GHC codebase is in 'mkDataConRep' in+-- "MkId", and so 'dataConUserTyVarsArePermuted' is only called at most once+-- during a data constructor's lifetime.++-- See Note [DataCon user type variable binders], as well as+-- Note [Data con wrappers and GADT syntax] for an explanation of what+-- mkDataConRep is doing with this function.+dataConUserTyVarsArePermuted :: DataCon -> Bool+dataConUserTyVarsArePermuted (MkData { dcUnivTyVars = univ_tvs,+ dcExTyVars = ex_tvs, dcEqSpec = eq_spec,+ dcUserTyVarBinders = user_tvbs }) =+ (filterEqSpec eq_spec univ_tvs ++ ex_tvs) /= binderVars user_tvbs {- %************************************************************************
basicTypes/DataCon.hs-boot view
@@ -1,4 +1,6 @@ module DataCon where++import GhcPrelude import Var( TyVar, TyVarBinder ) import Name( Name, NamedThing ) import {-# SOURCE #-} TyCon( TyCon )@@ -11,13 +13,12 @@ data DataCon data DataConRep data EqSpec-filterEqSpec :: [EqSpec] -> [TyVarBinder] -> [TyVarBinder] dataConName :: DataCon -> Name dataConTyCon :: DataCon -> TyCon-dataConUnivTyVarBinders :: DataCon -> [TyVarBinder] dataConExTyVars :: DataCon -> [TyVar]-dataConExTyVarBinders :: DataCon -> [TyVarBinder]+dataConUserTyVars :: DataCon -> [TyVar]+dataConUserTyVarBinders :: DataCon -> [TyVarBinder] dataConSourceArity :: DataCon -> Arity dataConFieldLabels :: DataCon -> [FieldLabel] dataConInstOrigArgTys :: DataCon -> [Type] -> [Type]
basicTypes/Demand.hs view
@@ -62,6 +62,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags import Outputable import Var ( Var )@@ -213,38 +215,40 @@ peculiar. -} --- Vanilla strictness domain+-- | Vanilla strictness domain data StrDmd- = HyperStr -- Hyper-strict- -- Bottom of the lattice- -- Note [HyperStr and Use demands]+ = HyperStr -- ^ Hyper-strict (bottom of the lattice).+ -- See Note [HyperStr and Use demands] - | SCall StrDmd -- Call demand+ | SCall StrDmd -- ^ Call demand -- Used only for values of function type - | SProd [ArgStr] -- Product+ | SProd [ArgStr] -- ^ Product -- Used only for values of product type -- Invariant: not all components are HyperStr (use HyperStr) -- not all components are Lazy (use HeadStr) - | HeadStr -- Head-Strict+ | HeadStr -- ^ Head-Strict -- A polymorphic demand: used for values of all types, -- including a type variable deriving ( Eq, Show ) +-- | Strictness of a function argument. type ArgStr = Str StrDmd -data Str s = Lazy -- Lazy- -- Top of the lattice- | Str ExnStr s+-- | Strictness demand.+data Str s = Lazy -- ^ Lazy (top of the lattice)+ | Str ExnStr s -- ^ Strict deriving ( Eq, Show ) +-- | How are exceptions handled for strict demands? data ExnStr -- See Note [Exceptions and strictness]- = VanStr -- "Vanilla" case, ordinary strictness+ = VanStr -- ^ "Vanilla" case, ordinary strictness - | ExnStr -- (Str ExnStr d) means be strict like 'd' but then degrade- -- the Termination info ThrowsExn to Dunno+ | ExnStr -- ^ @Str ExnStr d@ means be strict like @d@ but then degrade+ -- the 'Termination' info 'ThrowsExn' to 'Dunno'.+ -- e.g. the first argument of @catch@ has this strictness. deriving( Eq, Show ) -- Well-formedness preserving constructors for the Strictness domain@@ -300,7 +304,7 @@ lubStr (SProd sx) HyperStr = SProd sx lubStr (SProd _) HeadStr = HeadStr lubStr (SProd s1) (SProd s2)- | length s1 == length s2 = mkSProd (zipWith lubArgStr s1 s2)+ | s1 `equalLength` s2 = mkSProd (zipWith lubArgStr s1 s2) | otherwise = HeadStr lubStr (SProd _) (SCall _) = HeadStr lubStr HeadStr _ = HeadStr@@ -325,7 +329,7 @@ bothStr (SProd _) HyperStr = HyperStr bothStr (SProd s1) HeadStr = SProd s1 bothStr (SProd s1) (SProd s2)- | length s1 == length s2 = mkSProd (zipWith bothArgStr s1 s2)+ | s1 `equalLength` s2 = mkSProd (zipWith bothArgStr s1 s2) | otherwise = HyperStr -- Weird bothStr (SProd _) (SCall _) = HyperStr @@ -376,27 +380,28 @@ Abs -} --- Domain for genuine usage+-- | Domain for genuine usage data UseDmd- = UCall Count UseDmd -- Call demand for absence+ = UCall Count UseDmd -- ^ Call demand for absence. -- Used only for values of function type - | UProd [ArgUse] -- Product+ | UProd [ArgUse] -- ^ Product. -- Used only for values of product type -- See Note [Don't optimise UProd(Used) to Used]- -- [Invariant] Not all components are Abs- -- (in that case, use UHead)+ --+ -- Invariant: Not all components are Abs+ -- (in that case, use UHead) - | UHead -- May be used; but its sub-components are+ | UHead -- ^ May be used but its sub-components are -- definitely *not* used. Roughly U(AAA)- -- Eg the usage of x in x `seq` e+ -- e.g. the usage of @x@ in @x `seq` e@ -- A polymorphic demand: used for values of all types, -- including a type variable -- Since (UCall _ Abs) is ill-typed, UHead doesn't -- make sense for lambdas - | Used -- May be used; and its sub-components may be used- -- Top of the lattice+ | Used -- ^ May be used and its sub-components may be used.+ -- (top of the lattice) deriving ( Eq, Show ) -- Extended usage demand for absence and counting@@ -409,7 +414,7 @@ | Use Count u -- May be used with some cardinality deriving ( Eq, Show ) --- Abstract counting of usages+-- | Abstract counting of usages data Count = One | Many deriving ( Eq, Show ) @@ -459,7 +464,7 @@ lubUse (UCall _ _) _ = Used lubUse (UProd ux) UHead = UProd ux lubUse (UProd ux1) (UProd ux2)- | length ux1 == length ux2 = UProd $ zipWith lubArgUse ux1 ux2+ | ux1 `equalLength` ux2 = UProd $ zipWith lubArgUse ux1 ux2 | otherwise = Used lubUse (UProd {}) (UCall {}) = Used -- lubUse (UProd {}) Used = Used@@ -489,7 +494,7 @@ bothUse (UCall {}) _ = Used bothUse (UProd ux) UHead = UProd ux bothUse (UProd ux1) (UProd ux2)- | length ux1 == length ux2 = UProd $ zipWith bothArgUse ux1 ux2+ | ux1 `equalLength` ux2 = UProd $ zipWith bothArgUse ux1 ux2 | otherwise = Used bothUse (UProd {}) (UCall {}) = Used -- bothUse (UProd {}) Used = Used -- Note [Used should win]
basicTypes/FieldLabel.hs view
@@ -69,6 +69,8 @@ , mkFieldLabelOccs ) where +import GhcPrelude+ import OccName import Name
basicTypes/Id.hs view
@@ -5,7 +5,7 @@ \section[Id]{@Ids@: Value and constructor identifiers} -} -{-# LANGUAGE ImplicitParams, CPP #-}+{-# LANGUAGE CPP #-} -- | -- #name_types#@@ -53,7 +53,7 @@ setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo, zapLamIdInfo, zapIdDemandInfo, zapIdUsageInfo, zapIdUsageEnvInfo, zapIdUsedOnceInfo, zapIdTailCallInfo,- zapFragileIdInfo, zapIdStrictness,+ zapFragileIdInfo, zapIdStrictness, zapStableUnfolding, transferPolyIdInfo, -- ** Predicates on Ids@@ -74,7 +74,7 @@ DictId, isDictId, isEvVar, -- ** Join variables- JoinId, isJoinId, isJoinId_maybe, idJoinArity,+ JoinId, isJoinId, isJoinId_maybe, idJoinArity, isExitJoinId, asJoinId, asJoinId_maybe, zapJoinId, -- ** Inline pragma stuff@@ -116,8 +116,10 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags-import CoreSyn ( CoreRule, evaldUnfolding, Unfolding( NoUnfolding ) )+import CoreSyn ( CoreRule, isStableUnfolding, evaldUnfolding, Unfolding( NoUnfolding ) ) import IdInfo import BasicTypes@@ -201,7 +203,7 @@ setIdNotExported = Var.setIdNotExported localiseId :: Id -> Id--- Make an with the same unique and type as the+-- Make an Id with the same unique and type as the -- incoming Id, but with an *Internal* Name and *LocalId* flavour localiseId id | ASSERT( isId id ) isLocalId id && isInternalName name@@ -495,6 +497,10 @@ _ -> Nothing | otherwise = Nothing +-- see Note [Exitification] and see Note [Do not inline exit join points]+isExitJoinId :: Var -> Bool+isExitJoinId id = isJoinId id && isOneOcc (idOccInfo id) && occ_in_lam (idOccInfo id)+ idDataCon :: Id -> DataCon -- ^ Get from either the worker or the wrapper 'Id' to the 'DataCon'. Currently used only in the desugarer. --@@ -715,7 +721,7 @@ setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id ---------------------------------- -- Occcurrence INFO+ -- Occurrence INFO idOccInfo :: Id -> OccInfo idOccInfo id = occInfo (idInfo id) @@ -866,6 +872,11 @@ zapIdTailCallInfo :: Id -> Id zapIdTailCallInfo = zapInfo zapTailCallInfo++zapStableUnfolding :: Id -> Id+zapStableUnfolding id+ | isStableUnfolding (realIdUnfolding id) = setIdUnfolding id NoUnfolding+ | otherwise = id {- Note [transferPolyIdInfo]
basicTypes/IdInfo.hs view
@@ -82,6 +82,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import Class
basicTypes/IdInfo.hs-boot view
@@ -1,4 +1,5 @@ module IdInfo where+import GhcPrelude import Outputable data IdInfo data IdDetails
basicTypes/Lexeme.hs view
@@ -27,6 +27,8 @@ ) where +import GhcPrelude+ import FastString import Data.Char
basicTypes/Literal.hs view
@@ -44,6 +44,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TysPrim import PrelNames import Type@@ -222,6 +224,24 @@ ~~~~~~~~~~~~ -} +{- Note [Word/Int underflow/overflow]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+According to the Haskell Report 2010 (Sections 18.1 and 23.1 about signed and+unsigned integral types): "All arithmetic is performed modulo 2^n, where n is+the number of bits in the type."++GHC stores Word# and Int# constant values as Integer. Core optimizations such+as constant folding must ensure that the Integer value remains in the valid+target Word/Int range (see #13172). The following functions are used to+ensure this.++Note that we *don't* warn the user about overflow. It's not done at runtime+either, and compilation of completely harmless things like+ ((124076834 :: Word32) + (2147483647 :: Word32))+doesn't yield a warning. Instead we simply squash the value into the *target*+Int/Word range.+-}+ -- | Creates a 'Literal' of type @Int#@ mkMachInt :: DynFlags -> Integer -> Literal mkMachInt dflags x = ASSERT2( inIntRange dflags x, integer x )@@ -229,6 +249,7 @@ -- | Creates a 'Literal' of type @Int#@. -- If the argument is out of the (target-dependent) range, it is wrapped.+-- See Note [Word/Int underflow/overflow] mkMachIntWrap :: DynFlags -> Integer -> Literal mkMachIntWrap dflags i = MachInt $ case platformWordSize (targetPlatform dflags) of@@ -243,6 +264,7 @@ -- | Creates a 'Literal' of type @Word#@. -- If the argument is out of the (target-dependent) range, it is wrapped.+-- See Note [Word/Int underflow/overflow] mkMachWordWrap :: DynFlags -> Integer -> Literal mkMachWordWrap dflags i = MachWord $ case platformWordSize (targetPlatform dflags) of@@ -336,6 +358,7 @@ -- makes sense, e.g. for 'Char', 'Int', 'Word' and 'LitInteger'. For -- fixed-size integral literals, the result will be wrapped in -- accordance with the semantics of the target type.+-- See Note [Word/Int underflow/overflow] mapLitValue :: DynFlags -> (Integer -> Integer) -> Literal -> Literal mapLitValue _ f (MachChar c) = mkMachChar (fchar c) where fchar = chr . fromInteger . f . toInteger . ord@@ -491,7 +514,7 @@ literalType (LitInteger _ t) = t absentLiteralOf :: TyCon -> Maybe Literal--- Return a literal of the appropriate primtive+-- Return a literal of the appropriate primitive -- TyCon, to use as a placeholder when it doesn't matter absentLiteralOf tc = lookupUFM absent_lits (tyConName tc)
basicTypes/MkId.hs view
@@ -39,6 +39,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Rules import TysPrim import TysWiredIn@@ -276,7 +278,7 @@ sel_names = map idName (classAllSelIds clas) new_tycon = isNewTyCon tycon [data_con] = tyConDataCons tycon- tyvars = dataConUnivTyVarBinders data_con+ tyvars = dataConUserTyVarBinders data_con n_ty_args = length tyvars arg_tys = dataConRepArgTys data_con -- Includes the dictionary superclasses val_index = assoc "MkId.mkDictSelId" (sel_names `zip` [0..]) name@@ -551,7 +553,6 @@ -- Passing Nothing here allows the wrapper to inline when -- unsaturated. wrap_unf = mkInlineUnfolding wrap_rhs- wrap_tvs = (univ_tvs `minusList` map eqSpecTyVar eq_spec) ++ ex_tvs wrap_rhs = mkLams wrap_tvs $ mkLams wrap_args $ wrapFamInstBody tycon res_ty_args $@@ -566,6 +567,7 @@ where (univ_tvs, ex_tvs, eq_spec, theta, orig_arg_tys, _orig_res_ty) = dataConFullSig data_con+ wrap_tvs = dataConUserTyVars data_con res_ty_args = substTyVars (mkTvSubstPrs (map eqSpecPair eq_spec)) univ_tvs tycon = dataConTyCon data_con -- The representation TyCon (not family)@@ -593,11 +595,20 @@ (unboxers, boxers) = unzip wrappers (rep_tys, rep_strs) = unzip (concat rep_tys_w_strs) - wrapper_reqd = not (isNewTyCon tycon) -- Newtypes have only a worker- && (any isBanged (ev_ibangs ++ arg_ibangs)- -- Some forcing/unboxing (includes eq_spec)- || isFamInstTyCon tycon -- Cast result- || (not $ null eq_spec)) -- GADT+ wrapper_reqd =+ (not (isNewTyCon tycon)+ -- (Most) newtypes have only a worker, with the exception+ -- of some newtypes written with GADT syntax. See below.+ && (any isBanged (ev_ibangs ++ arg_ibangs)+ -- Some forcing/unboxing (includes eq_spec)+ || isFamInstTyCon tycon -- Cast result+ || (not $ null eq_spec))) -- GADT+ || dataConUserTyVarsArePermuted data_con+ -- If the data type was written with GADT syntax and+ -- orders the type variables differently from what the+ -- worker expects, it needs a data con wrapper to reorder+ -- the type variables.+ -- See Note [Data con wrappers and GADT syntax]. initial_wrap_app = Var (dataConWorkId data_con) `mkTyApps` res_ty_args@@ -663,6 +674,52 @@ The HsImplBangs passed are in 1-1 correspondence with the dataConOrigArgTys of the DataCon. +Note [Data con wrappers and unlifted types]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ data T = MkT !Int#++We certainly do not want to make a wrapper+ $WMkT x = case x of y { DEFAULT -> MkT y }++For a start, it's still to generate a no-op. But worse, since wrappers+are currently injected at TidyCore, we don't even optimise it away!+So the stupid case expression stays there. This actually happened for+the Integer data type (see Trac #1600 comment:66)!++Note [Data con wrappers and GADT syntax]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider these two very similar data types:++ data T1 a b = MkT1 b++ data T2 a b where+ MkT2 :: forall b a. b -> T2 a b++Despite their similar appearance, T2 will have a data con wrapper but T1 will+not. What sets them apart? The types of their constructors, which are:++ MkT1 :: forall a b. b -> T1 a b+ MkT2 :: forall b a. b -> T2 a b++MkT2's use of GADT syntax allows it to permute the order in which `a` and `b`+would normally appear. See Note [DataCon user type variable binders] in DataCon+for further discussion on this topic.++The worker data cons for T1 and T2, however, both have types such that `a` is+expected to come before `b` as arguments. Because MkT2 permutes this order, it+needs a data con wrapper to swizzle around the type variables to be in the+order the worker expects.++A somewhat surprising consequence of this is that *newtypes* can have data con+wrappers! After all, a newtype can also be written with GADT syntax:++ newtype T3 a b where+ MkT3 :: forall b a. b -> T3 a b++Again, this needs a wrapper data con to reorder the type variables. It does+mean that this newtype constructor requires another level of indirection when+being called, but the inliner should make swift work of that. -} -------------------------@@ -679,7 +736,7 @@ -> HsImplBang dataConSrcToImplBang dflags fam_envs arg_ty- (HsSrcBang ann unpk NoSrcStrict)+ (HsSrcBang ann unpk NoSrcStrict) | xopt LangExt.StrictData dflags -- StrictData => strict field = dataConSrcToImplBang dflags fam_envs arg_ty (HsSrcBang ann unpk SrcStrict)@@ -690,7 +747,11 @@ = HsLazy dataConSrcToImplBang dflags fam_envs arg_ty- (HsSrcBang _ unpk_prag SrcStrict)+ (HsSrcBang _ unpk_prag SrcStrict)+ | isUnliftedType arg_ty+ = HsLazy -- For !Int#, say, use HsLazy+ -- See Note [Data con wrappers and unlifted types]+ | not (gopt Opt_OmitInterfacePragmas dflags) -- Don't unpack if -fomit-iface-pragmas -- Don't unpack if we aren't optimising; rather arbitrarily, -- we use -fomit-iface-pragmas as the indication@@ -703,7 +764,7 @@ NoSrcUnpack -> gopt Opt_UnboxStrictFields dflags || (gopt Opt_UnboxSmallStrictFields dflags- && length rep_tys <= 1) -- See Note [Unpack one-wide fields]+ && rep_tys `lengthAtMost` 1) -- See Note [Unpack one-wide fields] srcUnpack -> isSrcUnpacked srcUnpack = case mb_co of Nothing -> HsUnpack Nothing@@ -1487,7 +1548,7 @@ Note [magicDictId magic] ~~~~~~~~~~~~~~~~~~~~~~~~~ The identifier `magicDict` is just a place-holder, which is used to-implement a primitve that we cannot define in Haskell but we can write+implement a primitive that we cannot define in Haskell but we can write in Core. It is declared with a place-holder type: magicDict :: forall a. a
basicTypes/Module.hs view
@@ -131,9 +131,14 @@ -- * Sets of Modules ModuleSet,- emptyModuleSet, mkModuleSet, moduleSetElts, extendModuleSet, elemModuleSet+ emptyModuleSet, mkModuleSet, moduleSetElts,+ extendModuleSet, extendModuleSetList, delModuleSet,+ elemModuleSet, intersectModuleSet, minusModuleSet, unionModuleSet,+ unitModuleSet ) where +import GhcPrelude+ import Config import Outputable import Unique@@ -1249,17 +1254,38 @@ -- | A set of 'Module's type ModuleSet = Set NDModule -mkModuleSet :: [Module] -> ModuleSet-extendModuleSet :: ModuleSet -> Module -> ModuleSet-emptyModuleSet :: ModuleSet-moduleSetElts :: ModuleSet -> [Module]-elemModuleSet :: Module -> ModuleSet -> Bool+mkModuleSet :: [Module] -> ModuleSet+mkModuleSet = Set.fromList . coerce -emptyModuleSet = Set.empty-mkModuleSet = Set.fromList . coerce+extendModuleSet :: ModuleSet -> Module -> ModuleSet extendModuleSet s m = Set.insert (NDModule m) s-moduleSetElts = sort . coerce . Set.toList-elemModuleSet = Set.member . coerce++extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet+extendModuleSetList s ms = foldl' (coerce . flip Set.insert) s ms++emptyModuleSet :: ModuleSet+emptyModuleSet = Set.empty++moduleSetElts :: ModuleSet -> [Module]+moduleSetElts = sort . coerce . Set.toList++elemModuleSet :: Module -> ModuleSet -> Bool+elemModuleSet = Set.member . coerce++intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet+intersectModuleSet = coerce Set.intersection++minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet+minusModuleSet = coerce Set.difference++delModuleSet :: ModuleSet -> Module -> ModuleSet+delModuleSet = coerce (flip Set.delete)++unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet+unionModuleSet = coerce Set.union++unitModuleSet :: Module -> ModuleSet+unitModuleSet = coerce Set.singleton {- A ModuleName has a Unique, so we can build mappings of these using
basicTypes/Module.hs-boot view
@@ -1,4 +1,6 @@ module Module where++import GhcPrelude import FastString data Module
basicTypes/Name.hs view
@@ -77,6 +77,8 @@ module OccName ) where +import GhcPrelude+ import {-# SOURCE #-} TyCoRep( TyThing ) import {-# SOURCE #-} PrelNames( starKindTyConKey, unicodeStarKindTyConKey ) @@ -107,7 +109,7 @@ data Name = Name { n_sort :: NameSort, -- What sort of name it is n_occ :: !OccName, -- Its occurrence name- n_uniq :: {-# UNPACK #-} !Int,+ n_uniq :: {-# UNPACK #-} !Unique, n_loc :: !SrcSpan -- Definition site } @@ -196,7 +198,7 @@ nameSrcLoc :: Name -> SrcLoc nameSrcSpan :: Name -> SrcSpan -nameUnique name = mkUniqueGrimily (n_uniq name)+nameUnique name = n_uniq name nameOccName name = n_occ name nameSrcLoc name = srcSpanStart (n_loc name) nameSrcSpan name = n_loc name@@ -332,7 +334,7 @@ -- | Create a name which is (for now at least) local to the current module and hence -- does not need a 'Module' to disambiguate it from other 'Name's mkInternalName :: Unique -> OccName -> SrcSpan -> Name-mkInternalName uniq occ loc = Name { n_uniq = getKey uniq+mkInternalName uniq occ loc = Name { n_uniq = uniq , n_sort = Internal , n_occ = occ , n_loc = loc }@@ -347,12 +349,12 @@ mkClonedInternalName :: Unique -> Name -> Name mkClonedInternalName uniq (Name { n_occ = occ, n_loc = loc })- = Name { n_uniq = getKey uniq, n_sort = Internal+ = Name { n_uniq = uniq, n_sort = Internal , n_occ = occ, n_loc = loc } mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name mkDerivedInternalName derive_occ uniq (Name { n_occ = occ, n_loc = loc })- = Name { n_uniq = getKey uniq, n_sort = Internal+ = Name { n_uniq = uniq, n_sort = Internal , n_occ = derive_occ occ, n_loc = loc } -- | Create a name which definitely originates in the given module@@ -361,13 +363,13 @@ -- (see Note [The Name Cache] in IfaceEnv), so don't just call mkExternalName -- with some fresh unique without populating the Name Cache mkExternalName uniq mod occ loc- = Name { n_uniq = getKey uniq, n_sort = External mod,+ = Name { n_uniq = uniq, n_sort = External mod, n_occ = occ, n_loc = loc } -- | Create a name which is actually defined by the compiler itself mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name mkWiredInName mod occ uniq thing built_in- = Name { n_uniq = getKey uniq,+ = Name { n_uniq = uniq, n_sort = WiredIn mod thing built_in, n_occ = occ, n_loc = wiredInSrcSpan } @@ -376,14 +378,14 @@ mkSystemName uniq occ = mkSystemNameAt uniq occ noSrcSpan mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name-mkSystemNameAt uniq occ loc = Name { n_uniq = getKey uniq, n_sort = System+mkSystemNameAt uniq occ loc = Name { n_uniq = uniq, n_sort = System , n_occ = occ, n_loc = loc } mkSystemVarName :: Unique -> FastString -> Name mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs) mkSysTvName :: Unique -> FastString -> Name-mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs)+mkSysTvName uniq fs = mkSystemName uniq (mkTyVarOccFS fs) -- | Make a name for a foreign call mkFCallName :: Unique -> String -> Name@@ -394,7 +396,7 @@ -- able to change a Name's Unique to match the cached -- one in the thing it's the name of. If you know what I mean. setNameUnique :: Name -> Unique -> Name-setNameUnique name uniq = name {n_uniq = getKey uniq}+setNameUnique name uniq = name {n_uniq = uniq} -- This is used for hsigs: we want to use the name of the originally exported -- entity, but edit the location to refer to the reexport site@@ -433,7 +435,7 @@ -} cmpName :: Name -> Name -> Ordering-cmpName n1 n2 = n_uniq n1 `compare` n_uniq n2+cmpName n1 n2 = n_uniq n1 `nonDetCmpUnique` n_uniq n2 -- | Compare Names lexicographically -- This only works for Names that originate in the source code or have been@@ -525,14 +527,13 @@ pprPrefixOcc = pprPrefixName pprName :: Name -> SDoc-pprName (Name {n_sort = sort, n_uniq = u, n_occ = occ})+pprName (Name {n_sort = sort, n_uniq = uniq, n_occ = occ}) = getPprStyle $ \ sty -> case sort of WiredIn mod _ builtin -> pprExternal sty uniq mod occ True builtin External mod -> pprExternal sty uniq mod occ False UserSyntax System -> pprSystem sty uniq occ Internal -> pprInternal sty uniq occ- where uniq = mkUniqueGrimily u pprExternal :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc pprExternal sty uniq mod occ is_wired is_builtin
basicTypes/Name.hs-boot view
@@ -1,3 +1,5 @@ module Name where +import GhcPrelude ()+ data Name
basicTypes/NameCache.hs view
@@ -10,6 +10,8 @@ , NameCache(..), OrigNameCache ) where +import GhcPrelude+ import Module import Name import UniqSupply
basicTypes/NameEnv.hs view
@@ -33,6 +33,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Digraph import Name import UniqFM@@ -61,7 +63,7 @@ -> (node -> [Name]) -- Uses -> [node] -> [SCC node]--- Peform dependency analysis on a group of definitions,+-- Perform dependency analysis on a group of definitions, -- where each definition may define more than one Name -- -- The get_defs and get_uses functions are called only once per node@@ -69,7 +71,8 @@ = stronglyConnCompFromEdgedVerticesUniq (map mk_node keyed_nodes) where keyed_nodes = nodes `zip` [(1::Int)..]- mk_node (node, key) = (node, key, mapMaybe (lookupNameEnv key_map) (get_uses node))+ mk_node (node, key) =+ DigraphNode node key (mapMaybe (lookupNameEnv key_map) (get_uses node)) key_map :: NameEnv Int -- Maps a Name to the key of the decl that defines it key_map = mkNameEnv [(name,key) | (node, key) <- keyed_nodes, name <- get_defs node]
basicTypes/NameSet.hs view
@@ -33,6 +33,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Name import UniqSet import Data.List (sortBy)
basicTypes/OccName.hs view
@@ -99,13 +99,14 @@ -- * Tidying up TidyOccEnv, emptyTidyOccEnv, initTidyOccEnv,- tidyOccName,- tidyOccNames, avoidClashesOccEnv,+ tidyOccName, avoidClashesOccEnv, -- FsEnv FastStringEnv, emptyFsEnv, lookupFsEnv, extendFsEnv, mkFsEnv ) where +import GhcPrelude+ import Util import Unique import DynFlags@@ -117,7 +118,6 @@ import Lexeme import Binary import Control.DeepSeq-import Data.List (mapAccumL) import Data.Char import Data.Data @@ -854,15 +854,13 @@ (id,id,id) :: (a3 -> a3, a2 -> a2, a1 -> a1) -This is achieved in tidyOccNames. It still uses tidyOccName to rename each name-on its own, but it prepares the TidyEnv (using avoidClashesOccEnv), by “blocking” every-name that occurs twice in the map. This way, none of the "a"s will get the-priviledge of keeping this name, and all of them will get a suitable numbery by-tidyOccName.+To achieve this, the function avoidClashesOccEnv can be used to prepare the+TidyEnv, by “blocking” every name that occurs twice in the map. This way, none+of the "a"s will get the privilege of keeping this name, and all of them will+get a suitable number by tidyOccName. -It may be inappropriate to use tidyOccNames if the caller needs access to the-intermediate environments (e.g. to tidy the tyVarKind of a type variable). In that-case, avoidClashesOccEnv should be used directly, and tidyOccName afterwards.+This prepared TidyEnv can then be used with tidyOccName. See tidyTyCoVarBndrs+for an example where this is used. This is #12382. @@ -880,11 +878,6 @@ add env (OccName _ fs) = addToUFM env fs 1 -- see Note [Tidying multiple names at once]-tidyOccNames :: TidyOccEnv -> [OccName] -> (TidyOccEnv, [OccName])-tidyOccNames env occs = mapAccumL tidyOccName env' occs- where- env' = avoidClashesOccEnv env occs- avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv avoidClashesOccEnv env occs = go env emptyUFM occs where
basicTypes/OccName.hs-boot view
@@ -1,3 +1,5 @@ module OccName where +import GhcPrelude ()+ data OccName
basicTypes/PatSyn.hs view
@@ -24,6 +24,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Type import Name import Outputable@@ -63,7 +65,7 @@ -- record pat syn or same length as -- psArgs - -- Universially-quantified type variables+ -- Universally-quantified type variables psUnivTyVars :: [TyVarBinder], -- Required dictionaries (may mention psUnivTyVars)@@ -76,7 +78,8 @@ psProvTheta :: ThetaType, -- Result type- psOrigResTy :: Type, -- Mentions only psUnivTyVars+ psResultTy :: Type, -- Mentions only psUnivTyVars+ -- See Note [Pattern synonym result type] -- See Note [Matchers and builders for pattern synonyms] psMatcher :: (Id, Bool),@@ -145,6 +148,43 @@ You can see it's existential because it doesn't appear in the result type (T3 b). +Note [Pattern synonym result type]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ data T a b = MkT b a++ pattern P :: a -> T [a] Bool+ pattern P x = MkT True [x]++P's psResultTy is (T a Bool), and it really only matches values of+type (T [a] Bool). For example, this is ill-typed++ f :: T p q -> String+ f (P x) = "urk"++This is differnet to the situation with GADTs:++ data S a where+ MkS :: Int -> S Bool++Now MkS (and pattern synonyms coming from MkS) can match a+value of type (S a), not just (S Bool); we get type refinement.++That in turn means that if you have a pattern++ P x :: T [ty] Bool++it's not entirely straightforward to work out the instantiation of+P's universal tyvars. You have to /match/+ the type of the pattern, (T [ty] Bool)+against+ the psResultTy for the pattern synonym, T [a] Bool+to get the instantiation a := ty.++This is very unlike DataCons, where univ tyvars match 1-1 the+arguments of the TyCon.++ Note [Pattern synonym representation] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Consider the following pattern synonym declaration@@ -174,7 +214,7 @@ psExTyVars = [b] psProvTheta = (Show (Maybe t), Ord b) psReqTheta = (Eq t, Num t)- psOrigResTy = T (Maybe t)+ psResultTy = T (Maybe t) Note [Matchers and builders for pattern synonyms] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -325,7 +365,7 @@ psInfix = declared_infix, psArgs = orig_args, psArity = length orig_args,- psOrigResTy = orig_res_ty,+ psResultTy = orig_res_ty, psMatcher = matcher, psBuilder = builder, psFieldLabels = field_labels@@ -368,7 +408,7 @@ patSynSig :: PatSyn -> ([TyVar], ThetaType, [TyVar], ThetaType, [Type], Type) patSynSig (MkPatSyn { psUnivTyVars = univ_tvs, psExTyVars = ex_tvs , psProvTheta = prov, psReqTheta = req- , psArgs = arg_tys, psOrigResTy = res_ty })+ , psArgs = arg_tys, psResultTy = res_ty }) = (binderVars univ_tvs, req, binderVars ex_tvs, prov, arg_tys, res_ty) patSynMatcher :: PatSyn -> (Id,Bool)@@ -394,7 +434,7 @@ patSynInstArgTys (MkPatSyn { psName = name, psUnivTyVars = univ_tvs , psExTyVars = ex_tvs, psArgs = arg_tys }) inst_tys- = ASSERT2( length tyvars == length inst_tys+ = ASSERT2( tyvars `equalLength` inst_tys , text "patSynInstArgTys" <+> ppr name $$ ppr tyvars $$ ppr inst_tys ) map (substTyWith tyvars inst_tys) arg_tys where@@ -405,11 +445,11 @@ -- E.g. pattern P x y = Just (x,x,y) -- P :: a -> b -> Just (a,a,b) -- (patSynInstResTy P [Int,Bool] = Maybe (Int,Int,Bool)--- NB: unlikepatSynInstArgTys, the inst_tys should be just the *universal* tyvars+-- NB: unlike patSynInstArgTys, the inst_tys should be just the *universal* tyvars patSynInstResTy (MkPatSyn { psName = name, psUnivTyVars = univ_tvs- , psOrigResTy = res_ty })+ , psResultTy = res_ty }) inst_tys- = ASSERT2( length univ_tvs == length inst_tys+ = ASSERT2( univ_tvs `equalLength` inst_tys , text "patSynInstResTy" <+> ppr name $$ ppr univ_tvs $$ ppr inst_tys ) substTyWith (binderVars univ_tvs) inst_tys res_ty @@ -417,7 +457,7 @@ pprPatSynType :: PatSyn -> SDoc pprPatSynType (MkPatSyn { psUnivTyVars = univ_tvs, psReqTheta = req_theta , psExTyVars = ex_tvs, psProvTheta = prov_theta- , psArgs = orig_args, psOrigResTy = orig_res_ty })+ , psArgs = orig_args, psResultTy = orig_res_ty }) = sep [ pprForAll univ_tvs , pprThetaArrowTy req_theta , ppWhen insert_empty_ctxt $ parens empty <+> darrow
basicTypes/RdrName.hs view
@@ -34,7 +34,8 @@ -- ** Destruction rdrNameOcc, rdrNameSpace, demoteRdrName, isRdrDataCon, isRdrTyVar, isRdrTc, isQual, isQual_maybe, isUnqual,- isOrig, isOrig_maybe, isExact, isExact_maybe, isSrcRdrName,+ isOrig, isOrig_maybe, isExact, isExact_maybe, isSrcRdrName, isStar,+ isUniStar, -- * Local mapping of 'RdrName' to 'Name.Name' LocalRdrEnv, emptyLocalRdrEnv, extendLocalRdrEnv, extendLocalRdrEnvList,@@ -66,6 +67,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Module import Name import Avail@@ -258,6 +261,10 @@ isExact_maybe (Exact n) = Just n isExact_maybe _ = Nothing +isStar, isUniStar :: RdrName -> Bool+isStar = (fsLit "*" ==) . occNameFS . rdrNameOcc+isUniStar = (fsLit "★" ==) . occNameFS . rdrNameOcc+ {- ************************************************************************ * *@@ -483,7 +490,7 @@ plusParent _ _ = NoParent hasParent :: Parent -> Parent -> Parent-#ifdef DEBUG+#if defined(DEBUG) hasParent p NoParent = p hasParent p p' | p /= p' = pprPanic "hasParent" (ppr p <+> ppr p') -- Parents should agree@@ -994,16 +1001,45 @@ {- Note [GlobalRdrEnv shadowing] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Before adding new names to the GlobalRdrEnv we nuke some existing entries;-this is "shadowing". The actual work is done by RdrEnv.shadowNames.+this is "shadowing". The actual work is done by RdrEnv.shadowName.+Suppose+ env' = shadowName env M.f++Then:+ * Looking up (Unqual f) in env' should succeed, returning M.f,+ even if env contains existing unqualified bindings for f.+ They are shadowed++ * Looking up (Qual M.f) in env' should succeed, returning M.f++ * Looking up (Qual X.f) in env', where X /= M, should be the same as+ looking up (Qual X.f) in env.+ That is, shadowName does /not/ delete earlier qualified bindings+ There are two reasons for shadowing: * The GHCi REPL - Ids bought into scope on the command line (eg let x = True) have External Names, like Ghci4.x. We want a new binding for 'x' (say)- to override the existing binding for 'x'.- See Note [Interactively-bound Ids in GHCi] in HscTypes+ to override the existing binding for 'x'. Example: + ghci> :load M -- Brings `x` and `M.x` into scope+ ghci> x+ ghci> "Hello"+ ghci> M.x+ ghci> "hello"+ ghci> let x = True -- Shadows `x`+ ghci> x -- The locally bound `x`+ -- NOT an ambiguous reference+ ghci> True+ ghci> M.x -- M.x is still in scope!+ ghci> "Hello"+ So when we add `x = True` we must not delete the `M.x` from the+ `GlobalRdrEnv`; rather we just want to make it "qualified only";+ hence the `mk_fake-imp_spec` in `shadowName`. See also Note+ [Interactively-bound Ids in GHCi] in HscTypes+ - Data types also have Extenal Names, like Ghci4.T; but we still want 'T' to mean the newly-declared 'T', not an old one. @@ -1012,10 +1048,10 @@ Consider a TH decl quote: module M where- f x = h [d| f = 3 |]- We must shadow the outer declaration of 'f', else we'll get a- complaint when extending the GlobalRdrEnv, saying that there are two- bindings for 'f'. There are several tricky points:+ f x = h [d| f = ...f...M.f... |]+ We must shadow the outer unqualified binding of 'f', else we'll get+ a complaint when extending the GlobalRdrEnv, saying that there are+ two bindings for 'f'. There are several tricky points: - This shadowing applies even if the binding for 'f' is in a where-clause, and hence is in the *local* RdrEnv not the *global*@@ -1203,9 +1239,8 @@ -- ^ Print out one place where the name was define/imported -- (With -dppr-debug, print them all) pprNameProvenance (GRE { gre_name = name, gre_lcl = lcl, gre_imp = iss })- = sdocWithPprDebug $ \dbg -> if dbg- then vcat pp_provs- else head pp_provs+ = ifPprDebug (vcat pp_provs)+ (head pp_provs) where pp_provs = pp_lcl ++ map pp_is iss pp_lcl = if lcl then [text "defined at" <+> ppr (nameSrcLoc name)]
basicTypes/SrcLoc.hs view
@@ -7,10 +7,6 @@ {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE RecordWildCards #-}-{-# OPTIONS_GHC -fno-omit-interface-pragmas #-}- -- Workaround for Trac #5252 crashes the bootstrap compiler without -O- -- When the earliest compiler we want to boostrap with is- -- GHC 7.2, we can make RealSrcLoc properly abstract -- | This module contains types that relate to the positions of things -- in source files, and allow tagging of those things with locations@@ -81,6 +77,8 @@ spans, isSubspanOf, sortLocated ) where +import GhcPrelude+ import Util import Json import Outputable@@ -552,7 +550,7 @@ -- GenLocated: -- Print spans without the file name etc -- ifPprDebug (braces (pprUserSpan False l))- ifPprDebug (braces (ppr l))+ whenPprDebug (braces (ppr l)) $$ ppr e {-
basicTypes/UniqSupply.hs view
@@ -29,6 +29,8 @@ initUniqSupply ) where +import GhcPrelude+ import Unique import GHC.IO
basicTypes/Unique.hs view
@@ -36,6 +36,7 @@ deriveUnique, -- Ditto newTagUnique, -- Used in CgCase initTyVarUnique,+ initExitJoinUnique, nonDetCmpUnique, isValidKnownKeyUnique, -- Used in PrelInfo.knownKeyNamesOkay @@ -68,6 +69,8 @@ #include "HsVersions.h" #include "Unique.h" +import GhcPrelude+ import BasicTypes import FastString import Outputable@@ -434,3 +437,6 @@ mkDataOccUnique fs = mkUnique 'd' (uniqueOfFS fs) mkTvOccUnique fs = mkUnique 'v' (uniqueOfFS fs) mkTcOccUnique fs = mkUnique 'c' (uniqueOfFS fs)++initExitJoinUnique :: Unique+initExitJoinUnique = mkUnique 's' 0
basicTypes/Var.hs view
@@ -64,6 +64,7 @@ TyVarBndr(..), ArgFlag(..), TyVarBinder, binderVar, binderVars, binderArgFlag, binderKind, isVisibleArgFlag, isInvisibleArgFlag, sameVis,+ mkTyVarBinder, mkTyVarBinders, -- ** Constructing TyVar's mkTyVar, mkTcTyVar,@@ -81,6 +82,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} TyCoRep( Type, Kind, pprKind ) import {-# SOURCE #-} TcType( TcTyVarDetails, pprTcTyVarDetails, vanillaSkolemTv ) import {-# SOURCE #-} IdInfo( IdDetails, IdInfo, coVarDetails, isCoVarDetails,@@ -158,7 +161,7 @@ {- Many passes apply a substitution, and it's very handy to have type- synonyms to remind us whether or not the subsitution has been applied -}+ synonyms to remind us whether or not the substitution has been applied -} type InVar = Var type InTyVar = TyVar@@ -374,7 +377,7 @@ -- Is something required to appear in source Haskell ('Required'), -- permitted by request ('Specified') (visible type application), or -- prohibited entirely from appearing in source Haskell ('Inferred')?--- See Note [TyBinders and ArgFlags] in TyCoRep+-- See Note [TyVarBndrs, TyVarBinders, TyConBinders, and visibility] in TyCoRep data ArgFlag = Required | Specified | Inferred deriving (Eq, Data) @@ -404,7 +407,7 @@ -- Type Variable Binder ----- TyVarBndr is polymorphic in both tyvar and visiblity fields:+-- TyVarBndr is polymorphic in both tyvar and visibility fields: -- * tyvar can be TyVar or IfaceTv -- * argf can be ArgFlag or TyConBndrVis data TyVarBndr tyvar argf = TvBndr tyvar argf@@ -428,6 +431,14 @@ binderKind :: TyVarBndr TyVar argf -> Kind binderKind (TvBndr tv _) = tyVarKind tv++-- | Make a named binder+mkTyVarBinder :: ArgFlag -> Var -> TyVarBinder+mkTyVarBinder vis var = TvBndr var vis++-- | Make many named binders+mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder]+mkTyVarBinders vis = map (mkTyVarBinder vis) {- ************************************************************************
basicTypes/VarEnv.hs view
@@ -34,7 +34,7 @@ extendDVarEnvList, lookupDVarEnv, elemDVarEnv, isEmptyDVarEnv, foldDVarEnv,- mapDVarEnv,+ mapDVarEnv, filterDVarEnv, modifyDVarEnv, alterDVarEnv, plusDVarEnv, plusDVarEnv_C,@@ -73,6 +73,8 @@ emptyTidyEnv ) where +import GhcPrelude+ import OccName import Var import VarSet@@ -554,6 +556,9 @@ mapDVarEnv :: (a -> b) -> DVarEnv a -> DVarEnv b mapDVarEnv = mapUDFM++filterDVarEnv :: (a -> Bool) -> DVarEnv a -> DVarEnv a+filterDVarEnv = filterUDFM alterDVarEnv :: (Maybe a -> Maybe a) -> DVarEnv a -> Var -> DVarEnv a alterDVarEnv = alterUDFM
basicTypes/VarSet.hs view
@@ -16,7 +16,7 @@ unionVarSet, unionVarSets, mapUnionVarSet, intersectVarSet, intersectsVarSet, disjointVarSet, isEmptyVarSet, delVarSet, delVarSetList, delVarSetByKey,- minusVarSet, filterVarSet,+ minusVarSet, filterVarSet, mapVarSet, anyVarSet, allVarSet, transCloVarSet, fixVarSet, lookupVarSet_Directly, lookupVarSet, lookupVarSetByName,@@ -32,7 +32,8 @@ extendDVarSet, extendDVarSetList, elemDVarSet, dVarSetElems, subDVarSet, unionDVarSet, unionDVarSets, mapUnionDVarSet,- intersectDVarSet, intersectsDVarSet, disjointDVarSet,+ intersectDVarSet, dVarSetIntersectVarSet,+ intersectsDVarSet, disjointDVarSet, isEmptyDVarSet, delDVarSet, delDVarSetList, minusDVarSet, foldDVarSet, filterDVarSet, dVarSetMinusVarSet, anyDVarSet, allDVarSet,@@ -44,6 +45,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Var ( Var, TyVar, CoVar, TyCoVar, Id ) import Unique import Name ( Name )@@ -145,8 +148,8 @@ allVarSet :: (Var -> Bool) -> VarSet -> Bool allVarSet = uniqSetAll --- There used to exist mapVarSet, see Note [Unsound mapUniqSet] in UniqSet for--- why it got removed.+mapVarSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b+mapVarSet = mapUniqSet fixVarSet :: (VarSet -> VarSet) -- Map the current set to a new set -> VarSet -> VarSet@@ -258,6 +261,9 @@ intersectDVarSet :: DVarSet -> DVarSet -> DVarSet intersectDVarSet = intersectUniqDSets++dVarSetIntersectVarSet :: DVarSet -> VarSet -> DVarSet+dVarSetIntersectVarSet = uniqDSetIntersectUniqSet -- | True if empty intersection disjointDVarSet :: DVarSet -> DVarSet -> Bool
cmm/Bitmap.hs view
@@ -18,6 +18,8 @@ #include "HsVersions.h" #include "MachDeps.h" +import GhcPrelude+ import SMRep import DynFlags import Util
cmm/BlockId.hs view
@@ -8,15 +8,16 @@ , blockLbl, infoTblLbl ) where +import GhcPrelude+ import CLabel import IdInfo import Name-import Outputable import Unique import UniqSupply -import Compiler.Hoopl as Hoopl hiding (Unique)-import Compiler.Hoopl.Internals (uniqueToLbl, lblToUnique)+import Hoopl.Label (Label, uniqueToLbl)+import Hoopl.Unique (intToUnique) ---------------------------------------------------------------- --- Block Ids, their environments, and their sets@@ -30,13 +31,7 @@ compilation unit in which it appears. -} -type BlockId = Hoopl.Label--instance Uniquable BlockId where- getUnique label = getUnique (lblToUnique label)--instance Outputable BlockId where- ppr label = ppr (getUnique label)+type BlockId = Label mkBlockId :: Unique -> BlockId mkBlockId unique = uniqueToLbl $ intToUnique $ getKey unique@@ -45,7 +40,8 @@ newBlockId = mkBlockId <$> getUniqueM blockLbl :: BlockId -> CLabel-blockLbl label = mkEntryLabel (mkFCallName (getUnique label) "block") NoCafRefs+blockLbl label = mkLocalBlockLabel (getUnique label) infoTblLbl :: BlockId -> CLabel-infoTblLbl label = mkInfoTableLabel (mkFCallName (getUnique label) "block") NoCafRefs+infoTblLbl label+ = mkBlockInfoTableLabel (mkFCallName (getUnique label) "block") NoCafRefs
+ cmm/BlockId.hs-boot view
@@ -0,0 +1,8 @@+module BlockId (BlockId, mkBlockId) where++import Hoopl.Label (Label)+import Unique (Unique)++type BlockId = Label++mkBlockId :: Unique -> BlockId
cmm/CLabel.hs view
@@ -14,12 +14,9 @@ pprDebugCLabel, mkClosureLabel,- mkSRTLabel, mkTopSRTLabel, mkInfoTableLabel, mkEntryLabel,- mkSlowEntryLabel,- mkConEntryLabel, mkRednCountsLabel, mkConInfoTableLabel, mkLargeSRTLabel,@@ -28,17 +25,13 @@ mkClosureTableLabel, mkBytesLabel, + mkLocalBlockLabel, mkLocalClosureLabel, mkLocalInfoTableLabel,- mkLocalEntryLabel,- mkLocalConEntryLabel,- mkLocalConInfoTableLabel, mkLocalClosureTableLabel, - mkReturnPtLabel,- mkReturnInfoLabel,- mkAltLabel,- mkDefaultLabel,+ mkBlockInfoTableLabel,+ mkBitmapLabel, mkStringLitLabel, @@ -47,8 +40,6 @@ mkAsmTempEndLabel, mkAsmTempDieLabel, - mkPlainModuleInitLabel,- mkSplitMarkerLabel, mkDirty_MUT_VAR_Label, mkUpdInfoLabel,@@ -61,12 +52,11 @@ mkSMAP_FROZEN_infoLabel, mkSMAP_FROZEN0_infoLabel, mkSMAP_DIRTY_infoLabel,- mkEMPTY_MVAR_infoLabel,+ mkBadAlignmentLabel, mkArrWords_infoLabel, mkTopTickyCtrLabel, mkCAFBlackHoleInfoTableLabel,- mkCAFBlackHoleEntryLabel, mkRtsPrimOpLabel, mkRtsSlowFastTickyCtrLabel, @@ -91,6 +81,8 @@ foreignLabelStdcallInfo, isBytesLabel, isForeignLabel,+ isSomeRODataLabel,+ isStaticClosureLabel, mkCCLabel, mkCCSLabel, DynamicLinkerLabelInfo(..),@@ -103,20 +95,23 @@ mkHpcTicksLabel, hasCAF,- needsCDecl, maybeAsmTemp, externallyVisibleCLabel,+ needsCDecl, maybeLocalBlockLabel, externallyVisibleCLabel, isMathFun, isCFunctionLabel, isGcPtrLabel, labelDynamic, -- * Conversions- toClosureLbl, toSlowEntryLbl, toEntryLbl, toInfoLbl, toRednCountsLbl, hasHaskellName,+ toClosureLbl, toSlowEntryLbl, toEntryLbl, toInfoLbl, hasHaskellName, pprCLabel ) where #include "HsVersions.h" +import GhcPrelude+ import IdInfo import BasicTypes+import {-# SOURCE #-} BlockId (BlockId, mkBlockId) import Packages import Module import Name@@ -135,8 +130,8 @@ -- ----------------------------------------------------------------------------- -- The CLabel type -{-- | CLabel is an abstract type that supports the following operations:+{- |+ 'CLabel' is an abstract type that supports the following operations: - Pretty printing @@ -155,6 +150,25 @@ more than one declaration for any given label). - Converting an info table label into an entry label.++ CLabel usage is a bit messy in GHC as they are used in a number of different+ contexts:++ - By the C-- AST to identify labels++ - By the unregisterised C code generator ("PprC") for naming functions (hence+ the name 'CLabel')++ - By the native and LLVM code generators to identify labels++ For extra fun, each of these uses a slightly different subset of constructors+ (e.g. 'AsmTempLabel' and 'AsmTempDerivedLabel' are used only in the NCG and+ LLVM backends).++ In general, we use 'IdLabel' to represent Haskell things early in the+ pipeline. However, later optimization passes will often represent blocks they+ create with 'LocalBlockLabel' where there is no obvious 'Name' to hang off the+ label. -} data CLabel@@ -177,6 +191,14 @@ | RtsLabel RtsLabelInfo + -- | A label associated with a block. These aren't visible outside of the+ -- compilation unit in which they are defined. These are generally used to+ -- name blocks produced by Cmm-to-Cmm passes and the native code generator,+ -- where we don't have a 'Name' to associate the label to and therefore can't+ -- use 'IdLabel'.+ | LocalBlockLabel+ {-# UNPACK #-} !Unique+ -- | A 'C' (or otherwise foreign) label. -- | ForeignLabel@@ -190,14 +212,13 @@ FunctionOrData - -- | A family of labels related to a particular case expression.- | CaseLabel- {-# UNPACK #-} !Unique -- Unique says which case expression- CaseLabelInfo-+ -- | Local temporary label used for native (or LLVM) code generation; must not+ -- appear outside of these contexts. Use primarily for debug information | AsmTempLabel {-# UNPACK #-} !Unique + -- | A label \"derived\" from another 'CLabel' by the addition of a suffix.+ -- Must not occur outside of the NCG or LLVM code generators. | AsmTempDerivedLabel CLabel FastString -- suffix@@ -205,9 +226,6 @@ | StringLitLabel {-# UNPACK #-} !Unique - | PlainModuleInitLabel -- without the version & way info- Module- | CC_Label CostCentre | CCS_Label CostCentreStack @@ -259,22 +277,18 @@ compare b1 b2 `thenCmp` compare c1 c2 compare (RtsLabel a1) (RtsLabel a2) = compare a1 a2+ compare (LocalBlockLabel u1) (LocalBlockLabel u2) = nonDetCmpUnique u1 u2 compare (ForeignLabel a1 b1 c1 d1) (ForeignLabel a2 b2 c2 d2) = compare a1 a2 `thenCmp` compare b1 b2 `thenCmp` compare c1 c2 `thenCmp` compare d1 d2- compare (CaseLabel u1 a1) (CaseLabel u2 a2) =- nonDetCmpUnique u1 u2 `thenCmp`- compare a1 a2 compare (AsmTempLabel u1) (AsmTempLabel u2) = nonDetCmpUnique u1 u2 compare (AsmTempDerivedLabel a1 b1) (AsmTempDerivedLabel a2 b2) = compare a1 a2 `thenCmp` compare b1 b2 compare (StringLitLabel u1) (StringLitLabel u2) = nonDetCmpUnique u1 u2- compare (PlainModuleInitLabel a1) (PlainModuleInitLabel a2) =- compare a1 a2 compare (CC_Label a1) (CC_Label a2) = compare a1 a2 compare (CCS_Label a1) (CCS_Label a2) =@@ -299,18 +313,16 @@ compare _ CmmLabel{} = GT compare RtsLabel{} _ = LT compare _ RtsLabel{} = GT+ compare LocalBlockLabel{} _ = LT+ compare _ LocalBlockLabel{} = GT compare ForeignLabel{} _ = LT compare _ ForeignLabel{} = GT- compare CaseLabel{} _ = LT- compare _ CaseLabel{} = GT compare AsmTempLabel{} _ = LT compare _ AsmTempLabel{} = GT compare AsmTempDerivedLabel{} _ = LT compare _ AsmTempDerivedLabel{} = GT compare StringLitLabel{} _ = LT compare _ StringLitLabel{} = GT- compare PlainModuleInitLabel{} _ = LT- compare _ PlainModuleInitLabel{} = GT compare CC_Label{} _ = LT compare _ CC_Label{} = GT compare CCS_Label{} _ = LT@@ -357,7 +369,8 @@ pprDebugCLabel :: CLabel -> SDoc pprDebugCLabel lbl = case lbl of- IdLabel{} -> ppr lbl <> (parens $ text "IdLabel")+ IdLabel _ _ info-> ppr lbl <> (parens $ text "IdLabel"+ <> whenPprDebug (text ":" <> text (show info))) CmmLabel pkg _name _info -> ppr lbl <> (parens $ text "CmmLabel" <+> ppr pkg) @@ -369,7 +382,7 @@ <+> ppr src <+> ppr funOrData) - _ -> ppr lbl <> (parens $ text "other CLabel)")+ _ -> ppr lbl <> (parens $ text "other CLabel") data IdLabelInfo@@ -393,16 +406,11 @@ | Bytes -- ^ Content of a string literal. See -- Note [Bytes label].-- deriving (Eq, Ord)-+ | BlockInfoTable -- ^ Like LocalInfoTable but for a proc-point block+ -- instead of a closure entry-point.+ -- See Note [Proc-point local block entry-point]. -data CaseLabelInfo- = CaseReturnPt- | CaseReturnInfo- | CaseAlt ConTag- | CaseDefault- deriving (Eq, Ord)+ deriving (Eq, Ord, Show) data RtsLabelInfo@@ -425,7 +433,7 @@ -- Determines the suffix appended to the name when a CLabel.CmmLabel -- is pretty printed. data CmmLabelInfo- = CmmInfo -- ^ misc rts info tabless, suffix _info+ = CmmInfo -- ^ misc rts info tables, suffix _info | CmmEntry -- ^ misc rts entry points, suffix _entry | CmmRetInfo -- ^ misc rts ret info tables, suffix _info | CmmRet -- ^ misc rts return points, suffix _ret@@ -450,56 +458,48 @@ -- Constructing IdLabels -- These are always local:-mkSlowEntryLabel :: Name -> CafInfo -> CLabel-mkSlowEntryLabel name c = IdLabel name c Slow mkTopSRTLabel :: Unique -> CLabel mkTopSRTLabel u = SRTLabel u -mkSRTLabel :: Name -> CafInfo -> CLabel mkRednCountsLabel :: Name -> CLabel-mkSRTLabel name c = IdLabel name c SRT mkRednCountsLabel name = IdLabel name NoCafRefs RednCounts -- Note [ticky for LNE] -- These have local & (possibly) external variants: mkLocalClosureLabel :: Name -> CafInfo -> CLabel mkLocalInfoTableLabel :: Name -> CafInfo -> CLabel-mkLocalEntryLabel :: Name -> CafInfo -> CLabel mkLocalClosureTableLabel :: Name -> CafInfo -> CLabel mkLocalClosureLabel name c = IdLabel name c Closure mkLocalInfoTableLabel name c = IdLabel name c LocalInfoTable-mkLocalEntryLabel name c = IdLabel name c LocalEntry mkLocalClosureTableLabel name c = IdLabel name c ClosureTable mkClosureLabel :: Name -> CafInfo -> CLabel mkInfoTableLabel :: Name -> CafInfo -> CLabel mkEntryLabel :: Name -> CafInfo -> CLabel mkClosureTableLabel :: Name -> CafInfo -> CLabel-mkLocalConInfoTableLabel :: CafInfo -> Name -> CLabel-mkLocalConEntryLabel :: CafInfo -> Name -> CLabel mkConInfoTableLabel :: Name -> CafInfo -> CLabel mkBytesLabel :: Name -> CLabel mkClosureLabel name c = IdLabel name c Closure mkInfoTableLabel name c = IdLabel name c InfoTable mkEntryLabel name c = IdLabel name c Entry mkClosureTableLabel name c = IdLabel name c ClosureTable-mkLocalConInfoTableLabel c con = IdLabel con c ConInfoTable-mkLocalConEntryLabel c con = IdLabel con c ConEntry mkConInfoTableLabel name c = IdLabel name c ConInfoTable mkBytesLabel name = IdLabel name NoCafRefs Bytes -mkConEntryLabel :: Name -> CafInfo -> CLabel-mkConEntryLabel name c = IdLabel name c ConEntry+mkBlockInfoTableLabel :: Name -> CafInfo -> CLabel+mkBlockInfoTableLabel name c = IdLabel name c BlockInfoTable+ -- See Note [Proc-point local block entry-point]. -- Constructing Cmm Labels mkDirty_MUT_VAR_Label, mkSplitMarkerLabel, mkUpdInfoLabel, mkBHUpdInfoLabel, mkIndStaticInfoLabel, mkMainCapabilityLabel, mkMAP_FROZEN_infoLabel, mkMAP_FROZEN0_infoLabel, mkMAP_DIRTY_infoLabel,- mkEMPTY_MVAR_infoLabel, mkTopTickyCtrLabel,- mkCAFBlackHoleInfoTableLabel, mkCAFBlackHoleEntryLabel,- mkArrWords_infoLabel, mkSMAP_FROZEN_infoLabel, mkSMAP_FROZEN0_infoLabel,- mkSMAP_DIRTY_infoLabel :: CLabel+ mkArrWords_infoLabel,+ mkTopTickyCtrLabel,+ mkCAFBlackHoleInfoTableLabel,+ mkSMAP_FROZEN_infoLabel, mkSMAP_FROZEN0_infoLabel,+ mkSMAP_DIRTY_infoLabel, mkBadAlignmentLabel :: CLabel mkDirty_MUT_VAR_Label = mkForeignLabel (fsLit "dirty_MUT_VAR") Nothing ForeignLabelInExternalPackage IsFunction mkSplitMarkerLabel = CmmLabel rtsUnitId (fsLit "__stg_split_marker") CmmCode mkUpdInfoLabel = CmmLabel rtsUnitId (fsLit "stg_upd_frame") CmmInfo@@ -509,14 +509,13 @@ mkMAP_FROZEN_infoLabel = CmmLabel rtsUnitId (fsLit "stg_MUT_ARR_PTRS_FROZEN") CmmInfo mkMAP_FROZEN0_infoLabel = CmmLabel rtsUnitId (fsLit "stg_MUT_ARR_PTRS_FROZEN0") CmmInfo mkMAP_DIRTY_infoLabel = CmmLabel rtsUnitId (fsLit "stg_MUT_ARR_PTRS_DIRTY") CmmInfo-mkEMPTY_MVAR_infoLabel = CmmLabel rtsUnitId (fsLit "stg_EMPTY_MVAR") CmmInfo mkTopTickyCtrLabel = CmmLabel rtsUnitId (fsLit "top_ct") CmmData mkCAFBlackHoleInfoTableLabel = CmmLabel rtsUnitId (fsLit "stg_CAF_BLACKHOLE") CmmInfo-mkCAFBlackHoleEntryLabel = CmmLabel rtsUnitId (fsLit "stg_CAF_BLACKHOLE") CmmEntry mkArrWords_infoLabel = CmmLabel rtsUnitId (fsLit "stg_ARR_WORDS") CmmInfo mkSMAP_FROZEN_infoLabel = CmmLabel rtsUnitId (fsLit "stg_SMALL_MUT_ARR_PTRS_FROZEN") CmmInfo mkSMAP_FROZEN0_infoLabel = CmmLabel rtsUnitId (fsLit "stg_SMALL_MUT_ARR_PTRS_FROZEN0") CmmInfo mkSMAP_DIRTY_infoLabel = CmmLabel rtsUnitId (fsLit "stg_SMALL_MUT_ARR_PTRS_DIRTY") CmmInfo+mkBadAlignmentLabel = CmmLabel rtsUnitId (fsLit "stg_badAlignment") CmmEntry ----- mkCmmInfoLabel, mkCmmEntryLabel, mkCmmRetInfoLabel, mkCmmRetLabel,@@ -531,6 +530,8 @@ mkCmmDataLabel pkg str = CmmLabel pkg str CmmData mkCmmClosureLabel pkg str = CmmLabel pkg str CmmClosure +mkLocalBlockLabel :: Unique -> CLabel+mkLocalBlockLabel u = LocalBlockLabel u -- Constructing RtsLabels mkRtsPrimOpLabel :: PrimOp -> CLabel@@ -584,6 +585,29 @@ isForeignLabel (ForeignLabel _ _ _ _) = True isForeignLabel _lbl = False +-- | Whether label is a static closure label (can come from haskell or cmm)+isStaticClosureLabel :: CLabel -> Bool+-- Closure defined in haskell (.hs)+isStaticClosureLabel (IdLabel _ _ Closure) = True+-- Closure defined in cmm+isStaticClosureLabel (CmmLabel _ _ CmmClosure) = True+isStaticClosureLabel _lbl = False++-- | Whether label is a .rodata label+isSomeRODataLabel :: CLabel -> Bool+-- info table defined in haskell (.hs)+isSomeRODataLabel (IdLabel _ _ ClosureTable) = True+isSomeRODataLabel (IdLabel _ _ ConInfoTable) = True+isSomeRODataLabel (IdLabel _ _ InfoTable) = True+isSomeRODataLabel (IdLabel _ _ LocalInfoTable) = True+isSomeRODataLabel (IdLabel _ _ BlockInfoTable) = True+-- static reference tables defined in haskell (.hs)+isSomeRODataLabel (IdLabel _ _ SRT) = True+isSomeRODataLabel (SRTLabel _) = True+-- info table defined in cmm (.cmm)+isSomeRODataLabel (CmmLabel _ _ CmmInfo) = True+isSomeRODataLabel _lbl = False+ -- | Get the label size field from a ForeignLabel foreignLabelStdcallInfo :: CLabel -> Maybe Int foreignLabelStdcallInfo (ForeignLabel _ info _ _) = info@@ -596,17 +620,6 @@ mkLargeSRTLabel uniq = LargeSRTLabel uniq mkBitmapLabel uniq = LargeBitmapLabel uniq ---- Constructin CaseLabels-mkReturnPtLabel :: Unique -> CLabel-mkReturnInfoLabel :: Unique -> CLabel-mkAltLabel :: Unique -> ConTag -> CLabel-mkDefaultLabel :: Unique -> CLabel-mkReturnPtLabel uniq = CaseLabel uniq CaseReturnPt-mkReturnInfoLabel uniq = CaseLabel uniq CaseReturnInfo-mkAltLabel uniq tag = CaseLabel uniq (CaseAlt tag)-mkDefaultLabel uniq = CaseLabel uniq CaseDefault- -- Constructing Cost Center Labels mkCCLabel :: CostCentre -> CLabel mkCCSLabel :: CostCentreStack -> CLabel@@ -652,8 +665,6 @@ mkAsmTempEndLabel :: CLabel -> CLabel mkAsmTempEndLabel l = mkAsmTempDerivedLabel l (fsLit "_end")-mkPlainModuleInitLabel :: Module -> CLabel-mkPlainModuleInitLabel mod = PlainModuleInitLabel mod -- | Construct a label for a DWARF Debug Information Entity (DIE) -- describing another symbol.@@ -664,36 +675,36 @@ -- Convert between different kinds of label toClosureLbl :: CLabel -> CLabel+toClosureLbl (IdLabel n _ BlockInfoTable)+ = pprPanic "toClosureLbl: BlockInfoTable" (ppr n) toClosureLbl (IdLabel n c _) = IdLabel n c Closure toClosureLbl (CmmLabel m str _) = CmmLabel m str CmmClosure toClosureLbl l = pprPanic "toClosureLbl" (ppr l) toSlowEntryLbl :: CLabel -> CLabel+toSlowEntryLbl (IdLabel n _ BlockInfoTable)+ = pprPanic "toSlowEntryLbl" (ppr n) toSlowEntryLbl (IdLabel n c _) = IdLabel n c Slow toSlowEntryLbl l = pprPanic "toSlowEntryLbl" (ppr l) toEntryLbl :: CLabel -> CLabel toEntryLbl (IdLabel n c LocalInfoTable) = IdLabel n c LocalEntry toEntryLbl (IdLabel n c ConInfoTable) = IdLabel n c ConEntry+toEntryLbl (IdLabel n _ BlockInfoTable) = mkLocalBlockLabel (nameUnique n)+ -- See Note [Proc-point local block entry-point]. toEntryLbl (IdLabel n c _) = IdLabel n c Entry-toEntryLbl (CaseLabel n CaseReturnInfo) = CaseLabel n CaseReturnPt toEntryLbl (CmmLabel m str CmmInfo) = CmmLabel m str CmmEntry toEntryLbl (CmmLabel m str CmmRetInfo) = CmmLabel m str CmmRet toEntryLbl l = pprPanic "toEntryLbl" (ppr l) toInfoLbl :: CLabel -> CLabel-toInfoLbl (IdLabel n c Entry) = IdLabel n c InfoTable toInfoLbl (IdLabel n c LocalEntry) = IdLabel n c LocalInfoTable toInfoLbl (IdLabel n c ConEntry) = IdLabel n c ConInfoTable toInfoLbl (IdLabel n c _) = IdLabel n c InfoTable-toInfoLbl (CaseLabel n CaseReturnPt) = CaseLabel n CaseReturnInfo toInfoLbl (CmmLabel m str CmmEntry) = CmmLabel m str CmmInfo toInfoLbl (CmmLabel m str CmmRet) = CmmLabel m str CmmRetInfo toInfoLbl l = pprPanic "CLabel.toInfoLbl" (ppr l) -toRednCountsLbl :: CLabel -> Maybe CLabel-toRednCountsLbl = fmap mkRednCountsLabel . hasHaskellName- hasHaskellName :: CLabel -> Maybe Name hasHaskellName (IdLabel n _ _) = Just n hasHaskellName _ = Nothing@@ -737,8 +748,7 @@ needsCDecl (LargeSRTLabel _) = False needsCDecl (LargeBitmapLabel _) = False needsCDecl (IdLabel _ _ _) = True-needsCDecl (CaseLabel _ _) = True-needsCDecl (PlainModuleInitLabel _) = True+needsCDecl (LocalBlockLabel _) = True needsCDecl (StringLitLabel _) = False needsCDecl (AsmTempLabel _) = False@@ -761,11 +771,11 @@ needsCDecl PicBaseLabel = panic "needsCDecl PicBaseLabel" needsCDecl (DeadStripPreventer {}) = panic "needsCDecl DeadStripPreventer" --- | If a label is a local temporary used for native code generation--- then return just its unique, otherwise nothing.-maybeAsmTemp :: CLabel -> Maybe Unique-maybeAsmTemp (AsmTempLabel uq) = Just uq-maybeAsmTemp _ = Nothing+-- | If a label is a local block label then return just its 'BlockId', otherwise+-- 'Nothing'.+maybeLocalBlockLabel :: CLabel -> Maybe BlockId+maybeLocalBlockLabel (LocalBlockLabel uq) = Just $ mkBlockId uq+maybeLocalBlockLabel _ = Nothing -- | Check whether a label corresponds to a C function that has@@ -868,12 +878,11 @@ -- externally visible if it has to be declared as exported -- in the .o file's symbol table; that is, made non-static. externallyVisibleCLabel :: CLabel -> Bool -- not C "static"-externallyVisibleCLabel (CaseLabel _ _) = False externallyVisibleCLabel (StringLitLabel _) = False externallyVisibleCLabel (AsmTempLabel _) = False externallyVisibleCLabel (AsmTempDerivedLabel _ _)= False-externallyVisibleCLabel (PlainModuleInitLabel _)= True externallyVisibleCLabel (RtsLabel _) = True+externallyVisibleCLabel (LocalBlockLabel _) = False externallyVisibleCLabel (CmmLabel _ _ _) = True externallyVisibleCLabel (ForeignLabel{}) = True externallyVisibleCLabel (IdLabel name _ info) = isExternalName name && externallyVisibleIdLabel info@@ -891,6 +900,7 @@ externallyVisibleIdLabel SRT = False externallyVisibleIdLabel LocalInfoTable = False externallyVisibleIdLabel LocalEntry = False+externallyVisibleIdLabel BlockInfoTable = False externallyVisibleIdLabel _ = True -- -----------------------------------------------------------------------------@@ -917,6 +927,7 @@ -- | Work out the general type of data at the address of this label -- whether it be code, data, or static GC object. labelType :: CLabel -> CLabelType+labelType (IdLabel _ _ info) = idInfoLabelType info labelType (CmmLabel _ _ CmmData) = DataLabel labelType (CmmLabel _ _ CmmClosure) = GcPtrLabel labelType (CmmLabel _ _ CmmCode) = CodeLabel@@ -928,21 +939,29 @@ labelType (RtsLabel (RtsSelectorInfoTable _ _)) = DataLabel labelType (RtsLabel (RtsApInfoTable _ _)) = DataLabel labelType (RtsLabel (RtsApFast _)) = CodeLabel-labelType (CaseLabel _ CaseReturnInfo) = DataLabel-labelType (CaseLabel _ _) = CodeLabel-labelType (PlainModuleInitLabel _) = DataLabel+labelType (RtsLabel _) = DataLabel+labelType (LocalBlockLabel _) = CodeLabel labelType (SRTLabel _) = DataLabel+labelType (ForeignLabel _ _ _ IsFunction) = CodeLabel+labelType (ForeignLabel _ _ _ IsData) = DataLabel+labelType (AsmTempLabel _) = panic "labelType(AsmTempLabel)"+labelType (AsmTempDerivedLabel _ _) = panic "labelType(AsmTempDerivedLabel)"+labelType (StringLitLabel _) = DataLabel+labelType (CC_Label _) = DataLabel+labelType (CCS_Label _) = DataLabel+labelType (DynamicLinkerLabel _ _) = DataLabel -- Is this right?+labelType PicBaseLabel = DataLabel+labelType (DeadStripPreventer _) = DataLabel+labelType (HpcTicksLabel _) = DataLabel labelType (LargeSRTLabel _) = DataLabel labelType (LargeBitmapLabel _) = DataLabel-labelType (ForeignLabel _ _ _ IsFunction) = CodeLabel-labelType (IdLabel _ _ info) = idInfoLabelType info-labelType _ = DataLabel idInfoLabelType :: IdLabelInfo -> CLabelType idInfoLabelType info = case info of InfoTable -> DataLabel LocalInfoTable -> DataLabel+ BlockInfoTable -> DataLabel Closure -> GcPtrLabel ConInfoTable -> DataLabel ClosureTable -> DataLabel@@ -975,6 +994,8 @@ | otherwise -> True + LocalBlockLabel _ -> False+ ForeignLabel _ _ source _ -> if os == OSMinGW32 then case source of@@ -996,8 +1017,6 @@ -- libraries True - PlainModuleInitLabel m -> (WayDyn `elem` ways dflags) && this_pkg /= (moduleUnitId m)- HpcTicksLabel m -> (WayDyn `elem` ways dflags) && this_mod /= m -- Note that DynamicLinkerLabels do NOT require dynamic linking themselves.@@ -1074,6 +1093,18 @@ ~~~~~~~~~~~~~~~~~~ For a top-level string literal 'foo', we have just one symbol 'foo_bytes', which points to a static data block containing the content of the literal.++Note [Proc-point local block entry-points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A label for a proc-point local block entry-point has no "_entry" suffix. With+`infoTblLbl` we derive an info table label from a proc-point block ID. If+we convert such an info table label into an entry label we must produce+the label without an "_entry" suffix. So an info table label records+the fact that it was derived from a block ID in `IdLabelInfo` as+`BlockInfoTable`.++The info table label and the local block label are both local labels+and are not externally visible. -} instance Outputable CLabel where@@ -1081,8 +1112,15 @@ pprCLabel :: Platform -> CLabel -> SDoc +pprCLabel platform (LocalBlockLabel u)+ = getPprStyle $ \ sty ->+ if asmStyle sty then+ ptext (asmTempLabelPrefix platform) <> pprUniqueAlways u+ else+ char '_' <> pprUniqueAlways u+ pprCLabel platform (AsmTempLabel u)- | cGhcWithNativeCodeGen == "YES"+ | not (platformUnregisterised platform) = getPprStyle $ \ sty -> if asmStyle sty then ptext (asmTempLabelPrefix platform) <> pprUniqueAlways u@@ -1092,8 +1130,9 @@ pprCLabel platform (AsmTempDerivedLabel l suf) | cGhcWithNativeCodeGen == "YES" = ptext (asmTempLabelPrefix platform)- <> case l of AsmTempLabel u -> pprUniqueAlways u- _other -> pprCLabel platform l+ <> case l of AsmTempLabel u -> pprUniqueAlways u+ LocalBlockLabel u -> pprUniqueAlways u+ _other -> pprCLabel platform l <> ftext suf pprCLabel platform (DynamicLinkerLabel info lbl)@@ -1136,15 +1175,6 @@ pprCLbl (StringLitLabel u) = pprUniqueAlways u <> text "_str" -pprCLbl (CaseLabel u CaseReturnPt)- = hcat [pprUniqueAlways u, text "_ret"]-pprCLbl (CaseLabel u CaseReturnInfo)- = hcat [pprUniqueAlways u, text "_info"]-pprCLbl (CaseLabel u (CaseAlt tag))- = hcat [pprUniqueAlways u, pp_cSEP, int tag, text "_alt"]-pprCLbl (CaseLabel u CaseDefault)- = hcat [pprUniqueAlways u, text "_dflt"]- pprCLbl (SRTLabel u) = pprUniqueAlways u <> pp_cSEP <> text "srt" @@ -1159,6 +1189,8 @@ pprCLbl (CmmLabel _ str CmmData) = ftext str pprCLbl (CmmLabel _ str CmmPrimCall) = ftext str +pprCLbl (LocalBlockLabel u) = text "blk_" <> pprUniqueAlways u+ pprCLbl (RtsLabel (RtsApFast str)) = ftext str <> text "_fast" pprCLbl (RtsLabel (RtsSelectorInfoTable upd_reqd offset))@@ -1226,9 +1258,6 @@ pprCLbl (CC_Label cc) = ppr cc pprCLbl (CCS_Label ccs) = ppr ccs -pprCLbl (PlainModuleInitLabel mod)- = text "__stginit_" <> ppr mod- pprCLbl (HpcTicksLabel mod) = text "_hpc_tickboxes_" <> ppr mod <> ptext (sLit "_hpc") @@ -1253,6 +1282,7 @@ ConInfoTable -> text "con_info" ClosureTable -> text "closure_tbl" Bytes -> text "bytes"+ BlockInfoTable -> text "info" ) @@ -1280,53 +1310,63 @@ _ -> sLit ".L" pprDynamicLinkerAsmLabel :: Platform -> DynamicLinkerLabelInfo -> CLabel -> SDoc-pprDynamicLinkerAsmLabel platform dllInfo lbl- = if platformOS platform == OSDarwin- then if platformArch platform == ArchX86_64- then case dllInfo of- CodeStub -> char 'L' <> ppr lbl <> text "$stub"- SymbolPtr -> char 'L' <> ppr lbl <> text "$non_lazy_ptr"- GotSymbolPtr -> ppr lbl <> text "@GOTPCREL"- GotSymbolOffset -> ppr lbl- else case dllInfo of- CodeStub -> char 'L' <> ppr lbl <> text "$stub"- SymbolPtr -> char 'L' <> ppr lbl <> text "$non_lazy_ptr"- _ -> panic "pprDynamicLinkerAsmLabel"+pprDynamicLinkerAsmLabel platform dllInfo lbl =+ case platformOS platform of+ OSDarwin+ | platformArch platform == ArchX86_64 ->+ case dllInfo of+ CodeStub -> char 'L' <> ppr lbl <> text "$stub"+ SymbolPtr -> char 'L' <> ppr lbl <> text "$non_lazy_ptr"+ GotSymbolPtr -> ppr lbl <> text "@GOTPCREL"+ GotSymbolOffset -> ppr lbl+ | otherwise ->+ case dllInfo of+ CodeStub -> char 'L' <> ppr lbl <> text "$stub"+ SymbolPtr -> char 'L' <> ppr lbl <> text "$non_lazy_ptr"+ _ -> panic "pprDynamicLinkerAsmLabel" - else if platformOS platform == OSAIX- then case dllInfo of- SymbolPtr -> text "LC.." <> ppr lbl -- GCC's naming convention- _ -> panic "pprDynamicLinkerAsmLabel"+ OSAIX ->+ case dllInfo of+ SymbolPtr -> text "LC.." <> ppr lbl -- GCC's naming convention+ _ -> panic "pprDynamicLinkerAsmLabel" - else if osElfTarget (platformOS platform)- then if platformArch platform == ArchPPC- then case dllInfo of- CodeStub -> -- See Note [.LCTOC1 in PPC PIC code]- ppr lbl <> text "+32768@plt"- SymbolPtr -> text ".LC_" <> ppr lbl- _ -> panic "pprDynamicLinkerAsmLabel"- else if platformArch platform == ArchX86_64- then case dllInfo of- CodeStub -> ppr lbl <> text "@plt"- GotSymbolPtr -> ppr lbl <> text "@gotpcrel"- GotSymbolOffset -> ppr lbl- SymbolPtr -> text ".LC_" <> ppr lbl- else if platformArch platform == ArchPPC_64 ELF_V1- || platformArch platform == ArchPPC_64 ELF_V2- then case dllInfo of- GotSymbolPtr -> text ".LC_" <> ppr lbl- <> text "@toc"- GotSymbolOffset -> ppr lbl- SymbolPtr -> text ".LC_" <> ppr lbl- _ -> panic "pprDynamicLinkerAsmLabel"- else case dllInfo of- CodeStub -> ppr lbl <> text "@plt"- SymbolPtr -> text ".LC_" <> ppr lbl- GotSymbolPtr -> ppr lbl <> text "@got"- GotSymbolOffset -> ppr lbl <> text "@gotoff"- else if platformOS platform == OSMinGW32- then case dllInfo of- SymbolPtr -> text "__imp_" <> ppr lbl- _ -> panic "pprDynamicLinkerAsmLabel"- else panic "pprDynamicLinkerAsmLabel"+ _ | osElfTarget (platformOS platform) -> elfLabel++ OSMinGW32 ->+ case dllInfo of+ SymbolPtr -> text "__imp_" <> ppr lbl+ _ -> panic "pprDynamicLinkerAsmLabel"++ _ -> panic "pprDynamicLinkerAsmLabel"+ where+ elfLabel+ | platformArch platform == ArchPPC+ = case dllInfo of+ CodeStub -> -- See Note [.LCTOC1 in PPC PIC code]+ ppr lbl <> text "+32768@plt"+ SymbolPtr -> text ".LC_" <> ppr lbl+ _ -> panic "pprDynamicLinkerAsmLabel"++ | platformArch platform == ArchX86_64+ = case dllInfo of+ CodeStub -> ppr lbl <> text "@plt"+ GotSymbolPtr -> ppr lbl <> text "@gotpcrel"+ GotSymbolOffset -> ppr lbl+ SymbolPtr -> text ".LC_" <> ppr lbl++ | platformArch platform == ArchPPC_64 ELF_V1+ || platformArch platform == ArchPPC_64 ELF_V2+ = case dllInfo of+ GotSymbolPtr -> text ".LC_" <> ppr lbl+ <> text "@toc"+ GotSymbolOffset -> ppr lbl+ SymbolPtr -> text ".LC_" <> ppr lbl+ _ -> panic "pprDynamicLinkerAsmLabel"++ | otherwise+ = case dllInfo of+ CodeStub -> ppr lbl <> text "@plt"+ SymbolPtr -> text ".LC_" <> ppr lbl+ GotSymbolPtr -> ppr lbl <> text "@got"+ GotSymbolOffset -> ppr lbl <> text "@gotoff"
cmm/Cmm.hs view
@@ -9,14 +9,12 @@ CmmBlock, RawCmmDecl, RawCmmGroup, Section(..), SectionType(..), CmmStatics(..), CmmStatic(..),+ isSecConstant, -- ** Blocks containing lists GenBasicBlock(..), blockId, ListGraph(..), pprBBlock, - -- * Cmm graphs- CmmReplGraph, GenCmmReplGraph, CmmFwdRewrite, CmmBwdRewrite,- -- * Info Tables CmmTopInfo(..), CmmStackInfo(..), CmmInfoTable(..), topInfoTable, ClosureTypeInfo(..),@@ -28,13 +26,17 @@ module CmmExpr, ) where +import GhcPrelude+ import CLabel import BlockId import CmmNode import SMRep import CmmExpr-import UniqSupply-import Compiler.Hoopl+import Hoopl.Block+import Hoopl.Collections+import Hoopl.Graph+import Hoopl.Label import Outputable import Data.Word ( Word8 )@@ -105,11 +107,6 @@ data GenCmmGraph n = CmmGraph { g_entry :: BlockId, g_graph :: Graph n C C } type CmmBlock = Block CmmNode C C -type CmmReplGraph e x = GenCmmReplGraph CmmNode e x-type GenCmmReplGraph n e x = UniqSM (Maybe (Graph n e x))-type CmmFwdRewrite f = FwdRewrite UniqSM CmmNode f-type CmmBwdRewrite f = BwdRewrite UniqSM CmmNode f- ----------------------------------------------------------------------------- -- Info Tables -----------------------------------------------------------------------------@@ -175,6 +172,18 @@ | CString | OtherSection String deriving (Show)++-- | Should a data in this section be considered constant+isSecConstant :: Section -> Bool+isSecConstant (Section t _) = case t of+ Text -> True+ ReadOnlyData -> True+ RelocatableReadOnlyData -> True+ ReadOnlyData16 -> True+ CString -> True+ Data -> False+ UninitialisedData -> False+ (OtherSection _) -> False data Section = Section SectionType CLabel
cmm/CmmBuildInfoTables.hs view
@@ -7,7 +7,13 @@ #include "HsVersions.h" -import Hoopl+import GhcPrelude hiding (succ)++import Hoopl.Block+import Hoopl.Graph+import Hoopl.Label+import Hoopl.Collections+import Hoopl.Dataflow import Digraph import Bitmap import CLabel@@ -30,9 +36,6 @@ import qualified Data.Set as Set import Control.Monad -import qualified Prelude as P-import Prelude hiding (succ)- foldSet :: (a -> b -> b) -> b -> Set a -> b foldSet = Set.foldr @@ -174,7 +177,7 @@ mkSRT topSRT = do localSRTs <- procpointSRT dflags (lbl topSRT) (elt_map topSRT) cafs return (topSRT, localSRTs)- in if length cafs > maxBmpSize dflags then+ in if cafs `lengthExceeds` maxBmpSize dflags then mkSRT (foldl add_if_missing topSRT cafs) else -- make sure all the cafs are near the bottom of the srt mkSRT (add_if_too_far topSRT cafs)@@ -216,7 +219,7 @@ sorted_ints = sort ints offset = head sorted_ints bitmap_entries = map (subtract offset) sorted_ints- len = P.last bitmap_entries + 1+ len = GhcPrelude.last bitmap_entries + 1 bitmap = intsToBitmap dflags len bitmap_entries maxBmpSize :: DynFlags -> Int@@ -278,7 +281,8 @@ in foldl (\env l -> Map.insert l (flatten env cafset) env) env lbls g = stronglyConnCompFromEdgedVerticesOrd- [ ((l,cafs), l, Set.elems cafs) | (cafs, Just l) <- localCAFs ]+ [ DigraphNode (l,cafs) l (Set.elems cafs)+ | (cafs, Just l) <- localCAFs ] flatten :: Map CLabel CAFSet -> CAFSet -> CAFSet flatten env cafset = foldSet (lookup env) Set.empty cafset
cmm/CmmCallConv.hs view
@@ -9,6 +9,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CmmExpr import SMRep import Cmm (Convention(..))@@ -129,9 +131,10 @@ assign_stk offset assts (r:rs) = assign_stk off' ((r, StackParam off') : assts) rs where w = typeWidth (arg_ty r)- size = (((widthInBytes w - 1) `div` word_size) + 1) * word_size off' = offset + size- word_size = wORD_SIZE dflags+ -- Stack arguments always take a whole number of words, we never+ -- pack them unlike constructor fields.+ size = roundUpToWords dflags (widthInBytes w) ----------------------------------------------------------------------------- -- Local information about the registers available
cmm/CmmCommonBlockElim.hs view
@@ -5,15 +5,19 @@ where +import GhcPrelude hiding (iterate, succ, unzip, zip)+ import BlockId import Cmm import CmmUtils import CmmSwitch (eqSwitchTargetWith) import CmmContFlowOpt -- import PprCmm ()-import Prelude hiding (iterate, succ, unzip, zip) -import Hoopl hiding (ChangeFlag)+import Hoopl.Block+import Hoopl.Graph+import Hoopl.Label+import Hoopl.Collections import Data.Bits import Data.Maybe (mapMaybe) import qualified Data.List as List@@ -205,7 +209,7 @@ = eqExprWith eqBid l1 l2 && eqExprWith eqBid r1 r2 eqMiddleWith eqBid (CmmUnsafeForeignCall t1 r1 a1) (CmmUnsafeForeignCall t2 r2 a2)- = t1 == t2 && r1 == r2 && and (zipWith (eqExprWith eqBid) a1 a2)+ = t1 == t2 && r1 == r2 && eqListWith (eqExprWith eqBid) a1 a2 eqMiddleWith _ _ _ = False eqExprWith :: (BlockId -> BlockId -> Bool)@@ -220,7 +224,7 @@ CmmStackSlot a1 i1 `eq` CmmStackSlot a2 i2 = eqArea a1 a2 && i1==i2 _e1 `eq` _e2 = False - xs `eqs` ys = and (zipWith eq xs ys)+ xs `eqs` ys = eqListWith eq xs ys eqLit (CmmBlock id1) (CmmBlock id2) = eqBid id1 id2 eqLit l1 l2 = l1 == l2@@ -243,7 +247,7 @@ (_,m',l') = blockSplit block' nodes' = filter (not . dont_care) (blockToList m') - equal = and (zipWith (eqMiddleWith eqBid) nodes nodes') &&+ equal = eqListWith (eqMiddleWith eqBid) nodes nodes' && eqLastWith eqBid l l' @@ -261,6 +265,11 @@ eqMaybeWith eltEq (Just e) (Just e') = eltEq e e' eqMaybeWith _ Nothing Nothing = True eqMaybeWith _ _ _ = False++eqListWith :: (a -> b -> Bool) -> [a] -> [b] -> Bool+eqListWith f (a : as) (b : bs) = f a b && eqListWith f as bs+eqListWith _ [] [] = True+eqListWith _ _ _ = False -- | Given a block map, ensure that all "target" blocks are covered by -- the same ticks as the respective "source" blocks. This not only
cmm/CmmContFlowOpt.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE GADTs #-}+{-# LANGUAGE BangPatterns #-} {-# OPTIONS_GHC -fno-warn-incomplete-patterns #-} module CmmContFlowOpt ( cmmCfgOpts@@ -8,16 +9,21 @@ ) where -import Hoopl+import GhcPrelude hiding (succ, unzip, zip)++import Hoopl.Block+import Hoopl.Collections+import Hoopl.Graph+import Hoopl.Label import BlockId import Cmm import CmmUtils import CmmSwitch (mapSwitchTargets) import Maybes import Panic+import Util import Control.Monad-import Prelude hiding (succ, unzip, zip) -- Note [What is shortcutting]@@ -49,7 +55,7 @@ -- -- This optimisation does three things: ----- - If a block finishes in an unconditonal branch to another block+-- - If a block finishes in an unconditional branch to another block -- and that is the only jump to that block we concatenate the -- destination block at the end of the current one. --@@ -190,7 +196,7 @@ maybe_concat :: CmmBlock -> (LabelMap CmmBlock, LabelMap BlockId, LabelMap Int) -> (LabelMap CmmBlock, LabelMap BlockId, LabelMap Int)- maybe_concat block (blocks, shortcut_map, backEdges)+ maybe_concat block (!blocks, !shortcut_map, !backEdges) -- If: -- (1) current block ends with unconditional branch to b' and -- (2) it has exactly one predecessor (namely, current block)@@ -392,7 +398,7 @@ -- Removing unreachable blocks removeUnreachableBlocksProc :: CmmDecl -> CmmDecl removeUnreachableBlocksProc proc@(CmmProc info lbl live g)- | length used_blocks < mapSize (toBlockMap g)+ | used_blocks `lengthLessThan` mapSize (toBlockMap g) = CmmProc info' lbl live g' | otherwise = proc@@ -412,4 +418,4 @@ used_blocks = postorderDfs g used_lbls :: LabelSet- used_lbls = foldr (setInsert . entryLabel) setEmpty used_blocks+ used_lbls = setFromList $ map entryLabel used_blocks
cmm/CmmExpr.hs view
@@ -28,6 +28,8 @@ ) where +import GhcPrelude+ import BlockId import CLabel import CmmMachOp
cmm/CmmImplementSwitchPlans.hs view
@@ -4,7 +4,9 @@ ) where -import Hoopl+import GhcPrelude++import Hoopl.Block import BlockId import Cmm import CmmUtils@@ -21,7 +23,7 @@ -- CmmSwitch and returned as a SwitchPlan; here is just the implementation in -- terms of Cmm code. See Note [Cmm Switches, the general plan] in CmmSwitch. ----- This division into different modules is both to clearly separte concerns,+-- This division into different modules is both to clearly separate concerns, -- but also because createSwitchPlan needs access to the constructors of -- SwitchTargets, a data type exported abstractly by CmmSwitch. --
cmm/CmmInfo.hs view
@@ -34,6 +34,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Cmm import CmmUtils import CLabel@@ -41,7 +43,7 @@ import Bitmap import Stream (Stream) import qualified Stream-import Hoopl+import Hoopl.Collections import Maybes import DynFlags@@ -133,7 +135,7 @@ -- return (top_decls ++ [CmmProc mapEmpty entry_lbl live blocks,- mkDataLits (Section Data info_lbl) info_lbl+ mkRODataLits info_lbl (CmmLabel entry_lbl : rel_std_info ++ rel_extra_bits)]) --@@ -415,9 +417,19 @@ -- ------------------------------------------------------------------------- +-- | Wrap a 'CmmExpr' in an alignment check when @-falignment-sanitisation@ is+-- enabled.+wordAligned :: DynFlags -> CmmExpr -> CmmExpr+wordAligned dflags e+ | gopt Opt_AlignmentSanitisation dflags+ = CmmMachOp (MO_AlignmentCheck (wORD_SIZE dflags) (wordWidth dflags)) [e]+ | otherwise+ = e+ closureInfoPtr :: DynFlags -> CmmExpr -> CmmExpr -- Takes a closure pointer and returns the info table pointer-closureInfoPtr dflags e = CmmLoad e (bWord dflags)+closureInfoPtr dflags e =+ CmmLoad (wordAligned dflags e) (bWord dflags) entryCode :: DynFlags -> CmmExpr -> CmmExpr -- Takes an info pointer (the first word of a closure)
cmm/CmmLayoutStack.hs view
@@ -1,8 +1,10 @@-{-# LANGUAGE CPP, RecordWildCards, GADTs #-}+{-# LANGUAGE BangPatterns, CPP, RecordWildCards, GADTs #-} module CmmLayoutStack ( cmmLayoutStack, setInfoTableStackMap ) where +import GhcPrelude hiding ((<*>))+ import StgCmmUtils ( callerSaveVolatileRegs ) -- XXX layering violation import StgCmmForeign ( saveThreadState, loadThreadState ) -- XXX layering violation @@ -17,7 +19,11 @@ import CmmLive import CmmProcPoint import SMRep-import Hoopl+import Hoopl.Block+import Hoopl.Collections+import Hoopl.Dataflow+import Hoopl.Graph+import Hoopl.Label import UniqSupply import StgCmmUtils ( newTemp ) import Maybes@@ -33,8 +39,6 @@ import Data.Bits import Data.List (nub) -import Prelude hiding ((<*>))- #include "HsVersions.h" {- Note [Stack Layout]@@ -60,6 +64,11 @@ The algorithm we use is a variant of linear-scan register allocation, where the stack is our register file. +We proceed in two passes, see Note [Two pass approach] for why they are not easy+to merge into one.++Pass 1:+ - First, we do a liveness analysis, which annotates every block with the variables live on entry to the block. @@ -80,9 +89,10 @@ - Look up the StackMap for this block. - - If this block is a proc point (or a call continuation, if we- aren't splitting proc points), emit instructions to reload all- the live variables from the stack, according to the StackMap.+ - If this block is a proc point (or a call continuation, if we aren't+ splitting proc points), we need to reload all the live variables from the+ stack - but this is done in Pass 2, which calculates more precise liveness+ information (see description of Pass 2). - Walk forwards through the instructions: - At an assignment x = Sp[loc]@@ -119,11 +129,53 @@ an input. I hate cyclic programming, but it's just too convenient sometimes.) -There are plenty of tricky details: update frames, proc points, return-addresses, foreign calls, and some ad-hoc optimisations that are-convenient to do here and effective in common cases. Comments in the-code below explain these.+ There are plenty of tricky details: update frames, proc points, return+ addresses, foreign calls, and some ad-hoc optimisations that are+ convenient to do here and effective in common cases. Comments in the+ code below explain these. +Pass 2:++- Calculate live registers, but taking into account that nothing is live at the+ entry to a proc point.++- At each proc point and call continuation insert reloads of live registers from+ the stack (they were saved by Pass 1).+++Note [Two pass approach]++The main reason for Pass 2 is being able to insert only the reloads that are+needed and the fact that the two passes need different liveness information.+Let's consider an example:++ .....+ \ /+ D <- proc point+ / \+ E F+ \ /+ G <- proc point+ |+ X++Pass 1 needs liveness assuming that local variables are preserved across calls.+This is important because it needs to save any local registers to the stack+(e.g., if register a is used in block X, it must be saved before any native+call).+However, for Pass 2, where we want to reload registers from stack (in a proc+point), this is overly conservative and would lead us to generate reloads in D+for things used in X, even though we're going to generate reloads in G anyway+(since it's also a proc point).+So Pass 2 calculates liveness knowing that nothing is live at the entry to a+proc point. This means that in D we only need to reload things used in E or F.+This can be quite important, for an extreme example see testcase for #3294.++Merging the two passes is not trivial - Pass 2 is a backward rewrite and Pass 1+is a forward one. Furthermore, Pass 1 is creating code that uses local registers+(saving them before a call), which the liveness analysis for Pass 2 must see to+be correct.+ -} @@ -201,9 +253,14 @@ layout dflags procpoints liveness entry entry_args rec_stackmaps rec_high_sp blocks - new_blocks' <- mapM (lowerSafeForeignCall dflags) new_blocks+ blocks_with_reloads <-+ insertReloadsAsNeeded dflags procpoints final_stackmaps entry new_blocks+ new_blocks' <- mapM (lowerSafeForeignCall dflags) blocks_with_reloads return (ofBlockList entry new_blocks', final_stackmaps) +-- -----------------------------------------------------------------------------+-- Pass 1+-- ----------------------------------------------------------------------------- layout :: DynFlags -> LabelSet -- proc points@@ -249,31 +306,25 @@ -- assignments in this block let stack1 = foldBlockNodesF (procMiddle acc_stackmaps) middle0 stack0 - -- (b) Insert assignments to reload all the live variables if this- -- block is a proc point- let middle1 = if entry_lbl `setMember` procpoints- then foldr blockCons middle0 (insertReloads stack0)- else middle0-- -- (c) Look at the last node and if we are making a call or+ -- (b) Look at the last node and if we are making a call or -- jumping to a proc point, we must save the live -- variables, adjust Sp, and construct the StackMaps for -- each of the successor blocks. See handleLastNode for -- details.- (middle2, sp_off, last1, fixup_blocks, out)+ (middle1, sp_off, last1, fixup_blocks, out) <- handleLastNode dflags procpoints liveness cont_info acc_stackmaps stack1 tscope middle0 last0 - -- (d) Manifest Sp: run over the nodes in the block and replace+ -- (c) Manifest Sp: run over the nodes in the block and replace -- CmmStackSlot with CmmLoad from Sp with a concrete offset. -- -- our block:- -- middle1 -- the original middle nodes- -- middle2 -- live variable saves from handleLastNode+ -- middle0 -- the original middle nodes+ -- middle1 -- live variable saves from handleLastNode -- Sp = Sp + sp_off -- Sp adjustment goes here -- last1 -- the last node --- let middle_pre = blockToList $ foldl blockSnoc middle1 middle2+ let middle_pre = blockToList $ foldl blockSnoc middle0 middle1 let final_blocks = manifestSp dflags final_stackmaps stack0 sp0 final_sp_high@@ -834,7 +885,6 @@ fixup_blocks' = map (mapBlock3' (id, adj_post_sp, id)) fixup_blocks - getAreaOff :: LabelMap StackMap -> (Area -> StackLoc) getAreaOff _ Old = 0 getAreaOff stackmaps (Young l) =@@ -849,7 +899,8 @@ where adj = CmmAssign spReg (cmmOffset dflags (CmmReg spReg) sp_off) -{-+{- Note [SP old/young offsets]+ Sp(L) is the Sp offset on entry to block L relative to the base of the OLD area. @@ -990,7 +1041,63 @@ , isGcPtrType (localRegType r) ] -- See Note [Unique Determinism and code generation] +-- -----------------------------------------------------------------------------+-- Pass 2+-- ----------------------------------------------------------------------------- +insertReloadsAsNeeded+ :: DynFlags+ -> ProcPointSet+ -> LabelMap StackMap+ -> BlockId+ -> [CmmBlock]+ -> UniqSM [CmmBlock]+insertReloadsAsNeeded dflags procpoints final_stackmaps entry blocks = do+ toBlockList . fst <$>+ rewriteCmmBwd liveLattice rewriteCC (ofBlockList entry blocks) mapEmpty+ where+ rewriteCC :: RewriteFun CmmLocalLive+ rewriteCC (BlockCC e_node middle0 x_node) fact_base0 = do+ let entry_label = entryLabel e_node+ stackmap = case mapLookup entry_label final_stackmaps of+ Just sm -> sm+ Nothing -> panic "insertReloadsAsNeeded: rewriteCC: stackmap"++ -- Merge the liveness from successor blocks and analyse the last+ -- node.+ joined = gen_kill dflags x_node $!+ joinOutFacts liveLattice x_node fact_base0+ -- What is live at the start of middle0.+ live_at_middle0 = foldNodesBwdOO (gen_kill dflags) middle0 joined++ -- If this is a procpoint we need to add the reloads, but only if+ -- they're actually live. Furthermore, nothing is live at the entry+ -- to a proc point.+ (middle1, live_with_reloads)+ | entry_label `setMember` procpoints+ = let reloads = insertReloads dflags stackmap live_at_middle0+ in (foldr blockCons middle0 reloads, emptyRegSet)+ | otherwise+ = (middle0, live_at_middle0)++ -- Final liveness for this block.+ !fact_base2 = mapSingleton entry_label live_with_reloads++ return (BlockCC e_node middle1 x_node, fact_base2)++insertReloads :: DynFlags -> StackMap -> CmmLocalLive -> [CmmNode O O]+insertReloads dflags stackmap live =+ [ CmmAssign (CmmLocal reg)+ -- This cmmOffset basically corresponds to manifesting+ -- @CmmStackSlot Old sp_off@, see Note [SP old/young offsets]+ (CmmLoad (cmmOffset dflags (CmmReg spReg) (sp_off - reg_off))+ (localRegType reg))+ | (reg, reg_off) <- stackSlotRegs stackmap+ , reg `elemRegSet` live+ ]+ where+ sp_off = sm_sp stackmap+ -- ----------------------------------------------------------------------------- -- Lowering safe foreign calls @@ -1131,14 +1238,6 @@ toWords :: DynFlags -> ByteOff -> WordOff toWords dflags x = x `quot` wORD_SIZE dflags---insertReloads :: StackMap -> [CmmNode O O]-insertReloads stackmap =- [ CmmAssign (CmmLocal r) (CmmLoad (CmmStackSlot Old sp)- (localRegType r))- | (r,sp) <- stackSlotRegs stackmap- ] stackSlotRegs :: StackMap -> [(LocalReg, StackLoc)]
cmm/CmmLex.x view
@@ -22,6 +22,8 @@ CmmToken(..), cmmlex, ) where +import GhcPrelude+ import CmmExpr import Lexer
cmm/CmmLint.hs view
@@ -10,7 +10,12 @@ cmmLint, cmmLintGraph ) where -import Hoopl+import GhcPrelude++import Hoopl.Block+import Hoopl.Collections+import Hoopl.Graph+import Hoopl.Label import Cmm import CmmUtils import CmmLive
cmm/CmmLive.hs view
@@ -12,11 +12,16 @@ ) where +import GhcPrelude+ import DynFlags import BlockId import Cmm import PprCmmExpr ()-import Hoopl+import Hoopl.Block+import Hoopl.Collections+import Hoopl.Dataflow+import Hoopl.Label import Maybes import Outputable
cmm/CmmMachOp.hs view
@@ -30,6 +30,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CmmType import Outputable import DynFlags@@ -136,9 +138,12 @@ -- Floating point vector operations | MO_VF_Add Length Width | MO_VF_Sub Length Width- | MO_VF_Neg Length Width -- unary -+ | MO_VF_Neg Length Width -- unary negation | MO_VF_Mul Length Width | MO_VF_Quot Length Width++ -- Alignment check (for -falignment-sanitisation)+ | MO_AlignmentCheck Int Width deriving (Eq, Show) pprMachOp :: MachOp -> SDoc@@ -417,6 +422,8 @@ MO_VF_Mul l w -> cmmVec l (cmmFloat w) MO_VF_Quot l w -> cmmVec l (cmmFloat w) MO_VF_Neg l w -> cmmVec l (cmmFloat w)++ MO_AlignmentCheck _ _ -> ty1 where (ty1:_) = tys @@ -507,6 +514,8 @@ MO_VF_Quot _ r -> [r,r] MO_VF_Neg _ r -> [r] + MO_AlignmentCheck _ r -> [r]+ ----------------------------------------------------------------------------- -- CallishMachOp -----------------------------------------------------------------------------@@ -575,8 +584,11 @@ | MO_Memcpy Int | MO_Memset Int | MO_Memmove Int+ | MO_Memcmp Int | MO_PopCnt Width+ | MO_Pdep Width+ | MO_Pext Width | MO_Clz Width | MO_Ctz Width @@ -607,6 +619,7 @@ MO_Memcpy _ -> ([], [AddrHint,AddrHint,NoHint]) MO_Memset _ -> ([], [AddrHint,NoHint,NoHint]) MO_Memmove _ -> ([], [AddrHint,AddrHint,NoHint])+ MO_Memcmp _ -> ([], [AddrHint, AddrHint, NoHint]) _ -> ([],[]) -- empty lists indicate NoHint @@ -616,4 +629,5 @@ MO_Memcpy align -> Just align MO_Memset align -> Just align MO_Memmove align -> Just align+ MO_Memcmp align -> Just align _ -> Nothing
cmm/CmmMonad.hs view
@@ -7,16 +7,15 @@ -- The parser for C-- requires access to a lot more of the 'DynFlags', -- so 'PD' provides access to 'DynFlags' via a 'HasDynFlags' instance. ------------------------------------------------------------------------------{-# LANGUAGE CPP #-} module CmmMonad ( PD(..) , liftP ) where +import GhcPrelude+ import Control.Monad-#if __GLASGOW_HASKELL__ > 710 import qualified Control.Monad.Fail as MonadFail-#endif import DynFlags import Lexer@@ -32,12 +31,10 @@ instance Monad PD where (>>=) = thenPD- fail = failPD+ fail = MonadFail.fail -#if __GLASGOW_HASKELL__ > 710 instance MonadFail.MonadFail PD where fail = failPD-#endif liftP :: P a -> PD a liftP (P f) = PD $ \_ s -> f s@@ -49,7 +46,7 @@ (PD m) `thenPD` k = PD $ \d s -> case m d s of POk s1 a -> unPD (k a) d s1- PFailed span err -> PFailed span err+ PFailed warnFn span err -> PFailed warnFn span err failPD :: String -> PD a failPD = liftP . fail
cmm/CmmNode.hs view
@@ -22,6 +22,8 @@ CmmTickScope(..), isTickSubScope, combineTickScopes, ) where +import GhcPrelude hiding (succ)+ import CodeGen.Platform import CmmExpr import CmmSwitch@@ -33,10 +35,11 @@ import CoreSyn (Tickish) import qualified Unique as U -import Compiler.Hoopl+import Hoopl.Block+import Hoopl.Graph+import Hoopl.Label import Data.Maybe import Data.List (tails,sortBy)-import Prelude hiding (succ) import Unique (nonDetCmpUnique) import Util
cmm/CmmOpt.hs view
@@ -2,9 +2,7 @@ -- The default iteration limit is a bit too low for the definitions -- in this module.-#if __GLASGOW_HASKELL__ >= 800 {-# OPTIONS_GHC -fmax-pmcheck-iterations=10000000 #-}-#endif ----------------------------------------------------------------------------- --@@ -23,6 +21,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CmmUtils import Cmm import DynFlags@@ -284,48 +284,68 @@ maybe_comparison _ _ _ = Nothing -- We can often do something with constants of 0 and 1 ...+-- See Note [Comparison operators] cmmMachOpFoldM dflags mop [x, y@(CmmLit (CmmInt 0 _))] = case mop of- MO_Add _ -> Just x- MO_Sub _ -> Just x- MO_Mul _ -> Just y- MO_And _ -> Just y- MO_Or _ -> Just x- MO_Xor _ -> Just x- MO_Shl _ -> Just x- MO_S_Shr _ -> Just x+ -- Arithmetic+ MO_Add _ -> Just x -- x + 0 = x+ MO_Sub _ -> Just x -- x - 0 = x+ MO_Mul _ -> Just y -- x * 0 = 0++ -- Logical operations+ MO_And _ -> Just y -- x & 0 = 0+ MO_Or _ -> Just x -- x | 0 = x+ MO_Xor _ -> Just x -- x `xor` 0 = x++ -- Shifts+ MO_Shl _ -> Just x -- x << 0 = x+ MO_S_Shr _ -> Just x -- ditto shift-right MO_U_Shr _ -> Just x- MO_Ne _ | isComparisonExpr x -> Just x- MO_Eq _ | Just x' <- maybeInvertCmmExpr x -> Just x'- MO_U_Gt _ | isComparisonExpr x -> Just x- MO_S_Gt _ | isComparisonExpr x -> Just x- MO_U_Lt _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 0 (wordWidth dflags))- MO_S_Lt _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 0 (wordWidth dflags))- MO_U_Ge _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 1 (wordWidth dflags))- MO_S_Ge _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 1 (wordWidth dflags))- MO_U_Le _ | Just x' <- maybeInvertCmmExpr x -> Just x'++ -- Comparisons; these ones are trickier+ -- See Note [Comparison operators]+ MO_Ne _ | isComparisonExpr x -> Just x -- (x > y) != 0 = x > y+ MO_Eq _ | Just x' <- maybeInvertCmmExpr x -> Just x' -- (x > y) == 0 = x <= y+ MO_U_Gt _ | isComparisonExpr x -> Just x -- (x > y) > 0 = x > y+ MO_S_Gt _ | isComparisonExpr x -> Just x -- ditto+ MO_U_Lt _ | isComparisonExpr x -> Just zero -- (x > y) < 0 = 0+ MO_S_Lt _ | isComparisonExpr x -> Just zero+ MO_U_Ge _ | isComparisonExpr x -> Just one -- (x > y) >= 0 = 1+ MO_S_Ge _ | isComparisonExpr x -> Just one++ MO_U_Le _ | Just x' <- maybeInvertCmmExpr x -> Just x' -- (x > y) <= 0 = x <= y MO_S_Le _ | Just x' <- maybeInvertCmmExpr x -> Just x' _ -> Nothing+ where+ zero = CmmLit (CmmInt 0 (wordWidth dflags))+ one = CmmLit (CmmInt 1 (wordWidth dflags)) cmmMachOpFoldM dflags mop [x, (CmmLit (CmmInt 1 rep))] = case mop of+ -- Arithmetic: x*1 = x, etc MO_Mul _ -> Just x MO_S_Quot _ -> Just x MO_U_Quot _ -> Just x MO_S_Rem _ -> Just $ CmmLit (CmmInt 0 rep) MO_U_Rem _ -> Just $ CmmLit (CmmInt 0 rep)- MO_Ne _ | Just x' <- maybeInvertCmmExpr x -> Just x'- MO_Eq _ | isComparisonExpr x -> Just x- MO_U_Lt _ | Just x' <- maybeInvertCmmExpr x -> Just x'- MO_S_Lt _ | Just x' <- maybeInvertCmmExpr x -> Just x'- MO_U_Gt _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 0 (wordWidth dflags))- MO_S_Gt _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 0 (wordWidth dflags))- MO_U_Le _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 1 (wordWidth dflags))- MO_S_Le _ | isComparisonExpr x -> Just $ CmmLit (CmmInt 1 (wordWidth dflags))- MO_U_Ge _ | isComparisonExpr x -> Just x++ -- Comparisons; trickier+ -- See Note [Comparison operators]+ MO_Ne _ | Just x' <- maybeInvertCmmExpr x -> Just x' -- (x>y) != 1 = x<=y+ MO_Eq _ | isComparisonExpr x -> Just x -- (x>y) == 1 = x>y+ MO_U_Lt _ | Just x' <- maybeInvertCmmExpr x -> Just x' -- (x>y) < 1 = x<=y+ MO_S_Lt _ | Just x' <- maybeInvertCmmExpr x -> Just x' -- ditto+ MO_U_Gt _ | isComparisonExpr x -> Just zero -- (x>y) > 1 = 0+ MO_S_Gt _ | isComparisonExpr x -> Just zero+ MO_U_Le _ | isComparisonExpr x -> Just one -- (x>y) <= 1 = 1+ MO_S_Le _ | isComparisonExpr x -> Just one+ MO_U_Ge _ | isComparisonExpr x -> Just x -- (x>y) >= 1 = x>y MO_S_Ge _ | isComparisonExpr x -> Just x _ -> Nothing+ where+ zero = CmmLit (CmmInt 0 (wordWidth dflags))+ one = CmmLit (CmmInt 1 (wordWidth dflags)) -- Now look for multiplication/division by powers of 2 (integers). @@ -337,35 +357,51 @@ MO_U_Quot rep | Just p <- exactLog2 n -> Just (cmmMachOpFold dflags (MO_U_Shr rep) [x, CmmLit (CmmInt p rep)])+ MO_U_Rem rep+ | Just _ <- exactLog2 n ->+ Just (cmmMachOpFold dflags (MO_And rep) [x, CmmLit (CmmInt (n - 1) rep)]) MO_S_Quot rep | Just p <- exactLog2 n,- CmmReg _ <- x -> -- We duplicate x below, hence require+ CmmReg _ <- x -> -- We duplicate x in signedQuotRemHelper, hence require -- it is a reg. FIXME: remove this restriction.- -- shift right is not the same as quot, because it rounds- -- to minus infinity, whereasq quot rounds toward zero.- -- To fix this up, we add one less than the divisor to the- -- dividend if it is a negative number.- --- -- to avoid a test/jump, we use the following sequence:- -- x1 = x >> word_size-1 (all 1s if -ve, all 0s if +ve)- -- x2 = y & (divisor-1)- -- result = (x+x2) >>= log2(divisor)- -- this could be done a bit more simply using conditional moves,- -- but we're processor independent here.- --- -- we optimise the divide by 2 case slightly, generating- -- x1 = x >> word_size-1 (unsigned)- -- return = (x + x1) >>= log2(divisor)- let- bits = fromIntegral (widthInBits rep) - 1- shr = if p == 1 then MO_U_Shr rep else MO_S_Shr rep- x1 = CmmMachOp shr [x, CmmLit (CmmInt bits rep)]- x2 = if p == 1 then x1 else- CmmMachOp (MO_And rep) [x1, CmmLit (CmmInt (n-1) rep)]- x3 = CmmMachOp (MO_Add rep) [x, x2]- in- Just (cmmMachOpFold dflags (MO_S_Shr rep) [x3, CmmLit (CmmInt p rep)])+ Just (cmmMachOpFold dflags (MO_S_Shr rep)+ [signedQuotRemHelper rep p, CmmLit (CmmInt p rep)])+ MO_S_Rem rep+ | Just p <- exactLog2 n,+ CmmReg _ <- x -> -- We duplicate x in signedQuotRemHelper, hence require+ -- it is a reg. FIXME: remove this restriction.+ -- We replace (x `rem` 2^p) by (x - (x `quot` 2^p) * 2^p).+ -- Moreover, we fuse MO_S_Shr (last operation of MO_S_Quot)+ -- and MO_S_Shl (multiplication by 2^p) into a single MO_And operation.+ Just (cmmMachOpFold dflags (MO_Sub rep)+ [x, cmmMachOpFold dflags (MO_And rep)+ [signedQuotRemHelper rep p, CmmLit (CmmInt (- n) rep)]]) _ -> Nothing+ where+ -- In contrast with unsigned integers, for signed ones+ -- shift right is not the same as quot, because it rounds+ -- to minus infinity, whereas quot rounds toward zero.+ -- To fix this up, we add one less than the divisor to the+ -- dividend if it is a negative number.+ --+ -- to avoid a test/jump, we use the following sequence:+ -- x1 = x >> word_size-1 (all 1s if -ve, all 0s if +ve)+ -- x2 = y & (divisor-1)+ -- result = x + x2+ -- this could be done a bit more simply using conditional moves,+ -- but we're processor independent here.+ --+ -- we optimise the divide by 2 case slightly, generating+ -- x1 = x >> word_size-1 (unsigned)+ -- return = x + x1+ signedQuotRemHelper :: Width -> Integer -> CmmExpr+ signedQuotRemHelper rep p = CmmMachOp (MO_Add rep) [x, x2]+ where+ bits = fromIntegral (widthInBits rep) - 1+ shr = if p == 1 then MO_U_Shr rep else MO_S_Shr rep+ x1 = CmmMachOp shr [x, CmmLit (CmmInt bits rep)]+ x2 = if p == 1 then x1 else+ CmmMachOp (MO_And rep) [x1, CmmLit (CmmInt (n-1) rep)] -- ToDo (#7116): optimise floating-point multiplication, e.g. x*2.0 -> x+x -- Unfortunately this needs a unique supply because x might not be a@@ -375,6 +411,17 @@ -- Anything else is just too hard. cmmMachOpFoldM _ _ _ = Nothing++{- Note [Comparison operators]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we have+ CmmCondBranch ((x>#y) == 1) t f+we really want to convert to+ CmmCondBranch (x>#y) t f++That's what the constant-folding operations on comparison operators do above.+-}+ -- ----------------------------------------------------------------------------- -- Utils
cmm/CmmParse.y view
@@ -200,6 +200,8 @@ { module CmmParse ( parseCmmFile ) where +import GhcPrelude+ import StgCmmExtCode import CmmCallConv import StgCmmProf@@ -992,6 +994,7 @@ ( "memcpy", memcpyLikeTweakArgs MO_Memcpy ), ( "memset", memcpyLikeTweakArgs MO_Memset ), ( "memmove", memcpyLikeTweakArgs MO_Memmove ),+ ( "memcmp", memcpyLikeTweakArgs MO_Memcmp ), ("prefetch0", (,) $ MO_Prefetch_Data 0), ("prefetch1", (,) $ MO_Prefetch_Data 1),@@ -1003,6 +1006,16 @@ ( "popcnt32", (,) $ MO_PopCnt W32 ), ( "popcnt64", (,) $ MO_PopCnt W64 ), + ( "pdep8", (,) $ MO_Pdep W8 ),+ ( "pdep16", (,) $ MO_Pdep W16 ),+ ( "pdep32", (,) $ MO_Pdep W32 ),+ ( "pdep64", (,) $ MO_Pdep W64 ),++ ( "pext8", (,) $ MO_Pext W8 ),+ ( "pext16", (,) $ MO_Pext W16 ),+ ( "pext32", (,) $ MO_Pext W32 ),+ ( "pext64", (,) $ MO_Pext W64 ),+ ( "cmpxchg8", (,) $ MO_Cmpxchg W8 ), ( "cmpxchg16", (,) $ MO_Cmpxchg W16 ), ( "cmpxchg32", (,) $ MO_Cmpxchg W32 ),@@ -1403,9 +1416,11 @@ -- reset the lex_state: the Lexer monad leaves some stuff -- in there we don't want. case unPD cmmParse dflags init_state of- PFailed span err -> do+ PFailed warnFn span err -> do let msg = mkPlainErrMsg dflags span err- return ((emptyBag, unitBag msg), Nothing)+ errMsgs = (emptyBag, unitBag msg)+ warnMsgs = warnFn dflags+ return (unionMessages warnMsgs errMsgs, Nothing) POk pst code -> do st <- initC let fcode = getCmm $ unEC code "global" (initEnv dflags) [] >> return ()
cmm/CmmPipeline.hs view
@@ -7,6 +7,8 @@ cmmPipeline ) where +import GhcPrelude+ import Cmm import CmmLint import CmmBuildInfoTables@@ -16,7 +18,7 @@ import CmmContFlowOpt import CmmLayoutStack import CmmSink-import Hoopl+import Hoopl.Collections import UniqSupply import DynFlags
cmm/CmmProcPoint.hs view
@@ -8,7 +8,7 @@ ) where -import Prelude hiding (last, unzip, succ, zip)+import GhcPrelude hiding (last, unzip, succ, zip) import DynFlags import BlockId@@ -19,13 +19,17 @@ import CmmInfo import CmmLive import CmmSwitch-import Data.List (sortBy)+import Data.List (sortBy, foldl') import Maybes import Control.Monad import Outputable import Platform import UniqSupply-import Hoopl+import Hoopl.Block+import Hoopl.Collections+import Hoopl.Dataflow+import Hoopl.Graph+import Hoopl.Label -- Compute a minimal set of proc points for a control-flow graph. @@ -271,12 +275,13 @@ let add_label map pp = mapInsert pp lbls map where lbls | pp == entry = (entry_label, fmap cit_lbl (mapLookup entry info_tbls)) | otherwise = (block_lbl, guard (setMember pp callPPs) >>- Just (toInfoLbl block_lbl))- where block_lbl = blockLbl pp+ Just info_table_lbl)+ where block_lbl = blockLbl pp+ info_table_lbl = infoTblLbl pp procLabels :: LabelMap (CLabel, Maybe CLabel)- procLabels = foldl add_label mapEmpty- (filter (flip mapMember (toBlockMap g)) (setElems procPoints))+ procLabels = foldl' add_label mapEmpty+ (filter (flip mapMember (toBlockMap g)) (setElems procPoints)) -- In each new graph, add blocks jumping off to the new procedures, -- and replace branches to procpoints with branches to the jump-off blocks
cmm/CmmSink.hs view
@@ -3,22 +3,45 @@ cmmSink ) where +import GhcPrelude+ import Cmm import CmmOpt import CmmLive import CmmUtils-import Hoopl+import Hoopl.Block+import Hoopl.Label+import Hoopl.Collections+import Hoopl.Graph import CodeGen.Platform import Platform (isARM, platformArch) import DynFlags+import Unique import UniqFM import PprCmm () +import qualified Data.IntSet as IntSet import Data.List (partition) import qualified Data.Set as Set import Data.Maybe +-- Compact sets for membership tests of local variables.++type LRegSet = IntSet.IntSet++emptyLRegSet :: LRegSet+emptyLRegSet = IntSet.empty++nullLRegSet :: LRegSet -> Bool+nullLRegSet = IntSet.null++insertLRegSet :: LocalReg -> LRegSet -> LRegSet+insertLRegSet l = IntSet.insert (getKey (getUnique l))++elemLRegSet :: LocalReg -> LRegSet -> Bool+elemLRegSet l = IntSet.member (getKey (getUnique l))+ -- ----------------------------------------------------------------------------- -- Sinking and inlining @@ -378,6 +401,8 @@ -- ----------------------------------------------------------------------------- -- Try to inline assignments into a node.+-- This also does constant folding for primpops, since+-- inlining opens up opportunities for doing so. tryToInline :: DynFlags@@ -392,7 +417,7 @@ , Assignments -- Remaining assignments ) -tryToInline dflags live node assigs = go usages node [] assigs+tryToInline dflags live node assigs = go usages node emptyLRegSet assigs where usages :: UniqFM Int -- Maps each LocalReg to a count of how often it is used usages = foldLocalRegsUsed dflags addUsage emptyUFM node@@ -415,7 +440,7 @@ inline_and_keep = keep inl_node -- inline the assignment, keep it keep node' = (final_node, a : rest')- where (final_node, rest') = go usages' node' (l:skipped) rest+ where (final_node, rest') = go usages' node' (insertLRegSet l skipped) rest usages' = foldLocalRegsUsed dflags (\m r -> addToUFM m r 2) usages rhs -- we must not inline anything that is mentioned in the RHS@@ -423,7 +448,7 @@ -- usages of the regs on the RHS to 2. cannot_inline = skipped `regsUsedIn` rhs -- Note [dependent assignments]- || l `elem` skipped+ || l `elemLRegSet` skipped || not (okToInline dflags rhs node) l_usages = lookupUFM usages l@@ -432,15 +457,40 @@ occurs_once = not l_live && l_usages == Just 1 occurs_none = not l_live && l_usages == Nothing - inl_node = mapExpDeep inline node- -- mapExpDeep is where the inlining actually takes place!- where inline (CmmReg (CmmLocal l')) | l == l' = rhs- inline (CmmRegOff (CmmLocal l') off) | l == l'+ inl_node = case mapExpDeep inl_exp node of+ -- See Note [Improving conditionals]+ CmmCondBranch (CmmMachOp (MO_Ne w) args)+ ti fi l+ -> CmmCondBranch (cmmMachOpFold dflags (MO_Eq w) args)+ fi ti l+ node' -> node'++ inl_exp :: CmmExpr -> CmmExpr+ -- inl_exp is where the inlining actually takes place!+ inl_exp (CmmReg (CmmLocal l')) | l == l' = rhs+ inl_exp (CmmRegOff (CmmLocal l') off) | l == l' = cmmOffset dflags rhs off -- re-constant fold after inlining- inline (CmmMachOp op args) = cmmMachOpFold dflags op args- inline other = other+ inl_exp (CmmMachOp op args) = cmmMachOpFold dflags op args+ inl_exp other = other +{- Note [Improving conditionals]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Given+ CmmCondBranch ((a >## b) != 1) t f+where a,b, are Floats, the constant folder /cannot/ turn it into+ CmmCondBranch (a <=## b) t f+because comparison on floats are not invertible+(see CmmMachOp.maybeInvertComparison).++What we want instead is simply to reverse the true/false branches thus+ CmmCondBranch ((a >## b) != 1) t f+-->+ CmmCondBranch (a >## b) f t++And we do that right here in tryToInline, just as we do cmmMachOpFold.+-}+ -- Note [dependent assignments] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --@@ -489,11 +539,11 @@ addUsage :: UniqFM Int -> LocalReg -> UniqFM Int addUsage m r = addToUFM_C (+) m r 1 -regsUsedIn :: [LocalReg] -> CmmExpr -> Bool-regsUsedIn [] _ = False+regsUsedIn :: LRegSet -> CmmExpr -> Bool+regsUsedIn ls _ | nullLRegSet ls = False regsUsedIn ls e = wrapRecExpf f e False- where f (CmmReg (CmmLocal l)) _ | l `elem` ls = True- f (CmmRegOff (CmmLocal l) _) _ | l `elem` ls = True+ where f (CmmReg (CmmLocal l)) _ | l `elemLRegSet` ls = True+ f (CmmRegOff (CmmLocal l) _) _ | l `elemLRegSet` ls = True f _ z = z -- we don't inline into CmmUnsafeForeignCall if the expression refers
cmm/CmmSwitch.hs view
@@ -11,9 +11,11 @@ createSwitchPlan, ) where +import GhcPrelude+ import Outputable import DynFlags-import Compiler.Hoopl (Label)+import Hoopl.Label (Label) import Data.Maybe import Data.List (groupBy)@@ -107,7 +109,7 @@ (M.Map Integer Label) -- The branches deriving (Show, Eq) --- | The smart constructr mkSwitchTargets normalises the map a bit:+-- | The smart constructor mkSwitchTargets normalises the map a bit: -- * No entries outside the range -- * No entries equal to the default -- * No default if all elements have explicit values
cmm/CmmType.hs view
@@ -31,6 +31,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags import FastString import Outputable
cmm/CmmUtils.hs view
@@ -64,6 +64,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TyCon ( PrimRep(..), PrimElemRep(..) ) import RepType ( UnaryType, SlotTy (..), typePrimRep1 ) @@ -79,7 +81,10 @@ import Data.Word import Data.Maybe import Data.Bits-import Hoopl+import Hoopl.Graph+import Hoopl.Label+import Hoopl.Block+import Hoopl.Collections --------------------------------------------------- --@@ -337,7 +342,6 @@ cmmULtWord dflags e1 e2 = CmmMachOp (mo_wordULt dflags) [e1, e2] cmmUGeWord dflags e1 e2 = CmmMachOp (mo_wordUGe dflags) [e1, e2] cmmUGtWord dflags e1 e2 = CmmMachOp (mo_wordUGt dflags) [e1, e2]---cmmShlWord dflags e1 e2 = CmmMachOp (mo_wordShl dflags) [e1, e2] cmmSLtWord dflags e1 e2 = CmmMachOp (mo_wordSLt dflags) [e1, e2] cmmUShrWord dflags e1 e2 = CmmMachOp (mo_wordUShr dflags) [e1, e2] cmmAddWord dflags e1 e2 = CmmMachOp (mo_wordAdd dflags) [e1, e2]@@ -389,23 +393,20 @@ --------------------------------------------------- -- Tag bits mask---cmmTagBits = CmmLit (mkIntCLit tAG_BITS) cmmTagMask, cmmPointerMask :: DynFlags -> CmmExpr cmmTagMask dflags = mkIntExpr dflags (tAG_MASK dflags) cmmPointerMask dflags = mkIntExpr dflags (complement (tAG_MASK dflags)) -- Used to untag a possibly tagged pointer -- A static label need not be untagged-cmmUntag :: DynFlags -> CmmExpr -> CmmExpr+cmmUntag, cmmIsTagged, cmmConstrTag1 :: DynFlags -> CmmExpr -> CmmExpr cmmUntag _ e@(CmmLit (CmmLabel _)) = e -- Default case cmmUntag dflags e = cmmAndWord dflags e (cmmPointerMask dflags) -- Test if a closure pointer is untagged-cmmIsTagged :: DynFlags -> CmmExpr -> CmmExpr cmmIsTagged dflags e = cmmNeWord dflags (cmmAndWord dflags e (cmmTagMask dflags)) (zeroExpr dflags) -cmmConstrTag1 :: DynFlags -> CmmExpr -> CmmExpr -- Get constructor tag, but one based. cmmConstrTag1 dflags e = cmmAndWord dflags e (cmmTagMask dflags) @@ -510,7 +511,7 @@ -- have both true and false successors. Block ordering can make a big difference -- in performance in the LLVM backend. Note that we rely crucially on the order -- of successors returned for CmmCondBranch by the NonLocal instance for CmmNode--- defind in cmm/CmmNode.hs. -GBM+-- defined in cmm/CmmNode.hs. -GBM toBlockListEntryFirstFalseFallthrough :: CmmGraph -> [CmmBlock] toBlockListEntryFirstFalseFallthrough g | mapNull m = []
cmm/Debug.hs view
@@ -22,6 +22,8 @@ UnwindExpr(..), toUnwindExpr ) where +import GhcPrelude+ import BlockId import CLabel import Cmm@@ -35,7 +37,10 @@ import SrcLoc import Util -import Compiler.Hoopl+import Hoopl.Block+import Hoopl.Collections+import Hoopl.Graph+import Hoopl.Label import Data.Maybe import Data.List ( minimumBy, nubBy )
− cmm/Hoopl.hs
@@ -1,29 +0,0 @@-{-# LANGUAGE RankNTypes, ScopedTypeVariables #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}--module Hoopl (- module Compiler.Hoopl,- module Hoopl.Dataflow,- ) where--import Compiler.Hoopl hiding- ( (<*>), mkLabel, mkBranch, mkMiddle, mkLast, -- clashes with our MkGraph- DataflowLattice, OldFact, NewFact, JoinFun,- fact_bot, fact_join, joinOutFacts, mkFactBase,- Unique,- FwdTransfer(..), FwdRewrite(..), FwdPass(..),- BwdTransfer(..), BwdRewrite(..), BwdPass(..),- mkFactBase, Fact,- mkBRewrite3, mkBTransfer3,- mkFRewrite3, mkFTransfer3,-- )--import Hoopl.Dataflow-import Outputable--instance Outputable LabelSet where- ppr = ppr . setElems--instance Outputable a => Outputable (LabelMap a) where- ppr = ppr . mapToList
+ cmm/Hoopl/Block.hs view
@@ -0,0 +1,328 @@+{-# LANGUAGE GADTs #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+module Hoopl.Block+ ( C+ , O+ , MaybeO(..)+ , IndexedCO+ , Block(..)+ , blockAppend+ , blockCons+ , blockFromList+ , blockJoin+ , blockJoinHead+ , blockJoinTail+ , blockSnoc+ , blockSplit+ , blockSplitHead+ , blockSplitTail+ , blockToList+ , emptyBlock+ , firstNode+ , foldBlockNodesB+ , foldBlockNodesB3+ , foldBlockNodesF+ , isEmptyBlock+ , lastNode+ , mapBlock+ , mapBlock'+ , mapBlock3'+ , replaceFirstNode+ , replaceLastNode+ ) where++import GhcPrelude++-- -----------------------------------------------------------------------------+-- Shapes: Open and Closed++-- | Used at the type level to indicate an "open" structure with+-- a unique, unnamed control-flow edge flowing in or out.+-- "Fallthrough" and concatenation are permitted at an open point.+data O++-- | Used at the type level to indicate a "closed" structure which+-- supports control transfer only through the use of named+-- labels---no "fallthrough" is permitted. The number of control-flow+-- edges is unconstrained.+data C++-- | Either type indexed by closed/open using type families+type family IndexedCO ex a b :: *+type instance IndexedCO C a _b = a+type instance IndexedCO O _a b = b++-- | Maybe type indexed by open/closed+data MaybeO ex t where+ JustO :: t -> MaybeO O t+ NothingO :: MaybeO C t++-- | Maybe type indexed by closed/open+data MaybeC ex t where+ JustC :: t -> MaybeC C t+ NothingC :: MaybeC O t+++instance Functor (MaybeO ex) where+ fmap _ NothingO = NothingO+ fmap f (JustO a) = JustO (f a)++instance Functor (MaybeC ex) where+ fmap _ NothingC = NothingC+ fmap f (JustC a) = JustC (f a)++-- -----------------------------------------------------------------------------+-- The Block type++-- | A sequence of nodes. May be any of four shapes (O/O, O/C, C/O, C/C).+-- Open at the entry means single entry, mutatis mutandis for exit.+-- A closed/closed block is a /basic/ block and can't be extended further.+-- Clients should avoid manipulating blocks and should stick to either nodes+-- or graphs.+data Block n e x where+ BlockCO :: n C O -> Block n O O -> Block n C O+ BlockCC :: n C O -> Block n O O -> n O C -> Block n C C+ BlockOC :: Block n O O -> n O C -> Block n O C++ BNil :: Block n O O+ BMiddle :: n O O -> Block n O O+ BCat :: Block n O O -> Block n O O -> Block n O O+ BSnoc :: Block n O O -> n O O -> Block n O O+ BCons :: n O O -> Block n O O -> Block n O O+++-- -----------------------------------------------------------------------------+-- Simple operations on Blocks++-- Predicates++isEmptyBlock :: Block n e x -> Bool+isEmptyBlock BNil = True+isEmptyBlock (BCat l r) = isEmptyBlock l && isEmptyBlock r+isEmptyBlock _ = False+++-- Building++emptyBlock :: Block n O O+emptyBlock = BNil++blockCons :: n O O -> Block n O x -> Block n O x+blockCons n b = case b of+ BlockOC b l -> (BlockOC $! (n `blockCons` b)) l+ BNil{} -> BMiddle n+ BMiddle{} -> n `BCons` b+ BCat{} -> n `BCons` b+ BSnoc{} -> n `BCons` b+ BCons{} -> n `BCons` b++blockSnoc :: Block n e O -> n O O -> Block n e O+blockSnoc b n = case b of+ BlockCO f b -> BlockCO f $! (b `blockSnoc` n)+ BNil{} -> BMiddle n+ BMiddle{} -> b `BSnoc` n+ BCat{} -> b `BSnoc` n+ BSnoc{} -> b `BSnoc` n+ BCons{} -> b `BSnoc` n++blockJoinHead :: n C O -> Block n O x -> Block n C x+blockJoinHead f (BlockOC b l) = BlockCC f b l+blockJoinHead f b = BlockCO f BNil `cat` b++blockJoinTail :: Block n e O -> n O C -> Block n e C+blockJoinTail (BlockCO f b) t = BlockCC f b t+blockJoinTail b t = b `cat` BlockOC BNil t++blockJoin :: n C O -> Block n O O -> n O C -> Block n C C+blockJoin f b t = BlockCC f b t++blockAppend :: Block n e O -> Block n O x -> Block n e x+blockAppend = cat+++-- Taking apart++firstNode :: Block n C x -> n C O+firstNode (BlockCO n _) = n+firstNode (BlockCC n _ _) = n++lastNode :: Block n x C -> n O C+lastNode (BlockOC _ n) = n+lastNode (BlockCC _ _ n) = n++blockSplitHead :: Block n C x -> (n C O, Block n O x)+blockSplitHead (BlockCO n b) = (n, b)+blockSplitHead (BlockCC n b t) = (n, BlockOC b t)++blockSplitTail :: Block n e C -> (Block n e O, n O C)+blockSplitTail (BlockOC b n) = (b, n)+blockSplitTail (BlockCC f b t) = (BlockCO f b, t)++-- | Split a closed block into its entry node, open middle block, and+-- exit node.+blockSplit :: Block n C C -> (n C O, Block n O O, n O C)+blockSplit (BlockCC f b t) = (f, b, t)++blockToList :: Block n O O -> [n O O]+blockToList b = go b []+ where go :: Block n O O -> [n O O] -> [n O O]+ go BNil r = r+ go (BMiddle n) r = n : r+ go (BCat b1 b2) r = go b1 $! go b2 r+ go (BSnoc b1 n) r = go b1 (n:r)+ go (BCons n b1) r = n : go b1 r++blockFromList :: [n O O] -> Block n O O+blockFromList = foldr BCons BNil++-- Modifying++replaceFirstNode :: Block n C x -> n C O -> Block n C x+replaceFirstNode (BlockCO _ b) f = BlockCO f b+replaceFirstNode (BlockCC _ b n) f = BlockCC f b n++replaceLastNode :: Block n x C -> n O C -> Block n x C+replaceLastNode (BlockOC b _) n = BlockOC b n+replaceLastNode (BlockCC l b _) n = BlockCC l b n++-- -----------------------------------------------------------------------------+-- General concatenation++cat :: Block n e O -> Block n O x -> Block n e x+cat x y = case x of+ BNil -> y++ BlockCO l b1 -> case y of+ BlockOC b2 n -> (BlockCC l $! (b1 `cat` b2)) n+ BNil -> x+ BMiddle _ -> BlockCO l $! (b1 `cat` y)+ BCat{} -> BlockCO l $! (b1 `cat` y)+ BSnoc{} -> BlockCO l $! (b1 `cat` y)+ BCons{} -> BlockCO l $! (b1 `cat` y)++ BMiddle n -> case y of+ BlockOC b2 n2 -> (BlockOC $! (x `cat` b2)) n2+ BNil -> x+ BMiddle{} -> BCons n y+ BCat{} -> BCons n y+ BSnoc{} -> BCons n y+ BCons{} -> BCons n y++ BCat{} -> case y of+ BlockOC b3 n2 -> (BlockOC $! (x `cat` b3)) n2+ BNil -> x+ BMiddle n -> BSnoc x n+ BCat{} -> BCat x y+ BSnoc{} -> BCat x y+ BCons{} -> BCat x y++ BSnoc{} -> case y of+ BlockOC b2 n2 -> (BlockOC $! (x `cat` b2)) n2+ BNil -> x+ BMiddle n -> BSnoc x n+ BCat{} -> BCat x y+ BSnoc{} -> BCat x y+ BCons{} -> BCat x y+++ BCons{} -> case y of+ BlockOC b2 n2 -> (BlockOC $! (x `cat` b2)) n2+ BNil -> x+ BMiddle n -> BSnoc x n+ BCat{} -> BCat x y+ BSnoc{} -> BCat x y+ BCons{} -> BCat x y+++-- -----------------------------------------------------------------------------+-- Mapping++-- | map a function over the nodes of a 'Block'+mapBlock :: (forall e x. n e x -> n' e x) -> Block n e x -> Block n' e x+mapBlock f (BlockCO n b ) = BlockCO (f n) (mapBlock f b)+mapBlock f (BlockOC b n) = BlockOC (mapBlock f b) (f n)+mapBlock f (BlockCC n b m) = BlockCC (f n) (mapBlock f b) (f m)+mapBlock _ BNil = BNil+mapBlock f (BMiddle n) = BMiddle (f n)+mapBlock f (BCat b1 b2) = BCat (mapBlock f b1) (mapBlock f b2)+mapBlock f (BSnoc b n) = BSnoc (mapBlock f b) (f n)+mapBlock f (BCons n b) = BCons (f n) (mapBlock f b)++-- | A strict 'mapBlock'+mapBlock' :: (forall e x. n e x -> n' e x) -> (Block n e x -> Block n' e x)+mapBlock' f = mapBlock3' (f, f, f)++-- | map over a block, with different functions to apply to first nodes,+-- middle nodes and last nodes respectively. The map is strict.+--+mapBlock3' :: forall n n' e x .+ ( n C O -> n' C O+ , n O O -> n' O O,+ n O C -> n' O C)+ -> Block n e x -> Block n' e x+mapBlock3' (f, m, l) b = go b+ where go :: forall e x . Block n e x -> Block n' e x+ go (BlockOC b y) = (BlockOC $! go b) $! l y+ go (BlockCO x b) = (BlockCO $! f x) $! (go b)+ go (BlockCC x b y) = ((BlockCC $! f x) $! go b) $! (l y)+ go BNil = BNil+ go (BMiddle n) = BMiddle $! m n+ go (BCat x y) = (BCat $! go x) $! (go y)+ go (BSnoc x n) = (BSnoc $! go x) $! (m n)+ go (BCons n x) = (BCons $! m n) $! (go x)++-- -----------------------------------------------------------------------------+-- Folding+++-- | Fold a function over every node in a block, forward or backward.+-- The fold function must be polymorphic in the shape of the nodes.+foldBlockNodesF3 :: forall n a b c .+ ( n C O -> a -> b+ , n O O -> b -> b+ , n O C -> b -> c)+ -> (forall e x . Block n e x -> IndexedCO e a b -> IndexedCO x c b)+foldBlockNodesF :: forall n a .+ (forall e x . n e x -> a -> a)+ -> (forall e x . Block n e x -> IndexedCO e a a -> IndexedCO x a a)+foldBlockNodesB3 :: forall n a b c .+ ( n C O -> b -> c+ , n O O -> b -> b+ , n O C -> a -> b)+ -> (forall e x . Block n e x -> IndexedCO x a b -> IndexedCO e c b)+foldBlockNodesB :: forall n a .+ (forall e x . n e x -> a -> a)+ -> (forall e x . Block n e x -> IndexedCO x a a -> IndexedCO e a a)++foldBlockNodesF3 (ff, fm, fl) = block+ where block :: forall e x . Block n e x -> IndexedCO e a b -> IndexedCO x c b+ block (BlockCO f b ) = ff f `cat` block b+ block (BlockCC f b l) = ff f `cat` block b `cat` fl l+ block (BlockOC b l) = block b `cat` fl l+ block BNil = id+ block (BMiddle node) = fm node+ block (b1 `BCat` b2) = block b1 `cat` block b2+ block (b1 `BSnoc` n) = block b1 `cat` fm n+ block (n `BCons` b2) = fm n `cat` block b2+ cat :: forall a b c. (a -> b) -> (b -> c) -> a -> c+ cat f f' = f' . f++foldBlockNodesF f = foldBlockNodesF3 (f, f, f)++foldBlockNodesB3 (ff, fm, fl) = block+ where block :: forall e x . Block n e x -> IndexedCO x a b -> IndexedCO e c b+ block (BlockCO f b ) = ff f `cat` block b+ block (BlockCC f b l) = ff f `cat` block b `cat` fl l+ block (BlockOC b l) = block b `cat` fl l+ block BNil = id+ block (BMiddle node) = fm node+ block (b1 `BCat` b2) = block b1 `cat` block b2+ block (b1 `BSnoc` n) = block b1 `cat` fm n+ block (n `BCons` b2) = fm n `cat` block b2+ cat :: forall a b c. (b -> c) -> (a -> b) -> a -> c+ cat f f' = f . f'++foldBlockNodesB f = foldBlockNodesB3 (f, f, f)+
+ cmm/Hoopl/Collections.hs view
@@ -0,0 +1,89 @@+{-# LANGUAGE TypeFamilies #-}+module Hoopl.Collections+ ( IsSet(..)+ , setInsertList, setDeleteList, setUnions+ , IsMap(..)+ , mapInsertList, mapDeleteList, mapUnions+ ) where++import GhcPrelude++import Data.List (foldl', foldl1')++class IsSet set where+ type ElemOf set++ setNull :: set -> Bool+ setSize :: set -> Int+ setMember :: ElemOf set -> set -> Bool++ setEmpty :: set+ setSingleton :: ElemOf set -> set+ setInsert :: ElemOf set -> set -> set+ setDelete :: ElemOf set -> set -> set++ setUnion :: set -> set -> set+ setDifference :: set -> set -> set+ setIntersection :: set -> set -> set+ setIsSubsetOf :: set -> set -> Bool++ setFold :: (ElemOf set -> b -> b) -> b -> set -> b++ setElems :: set -> [ElemOf set]+ setFromList :: [ElemOf set] -> set++-- Helper functions for IsSet class+setInsertList :: IsSet set => [ElemOf set] -> set -> set+setInsertList keys set = foldl' (flip setInsert) set keys++setDeleteList :: IsSet set => [ElemOf set] -> set -> set+setDeleteList keys set = foldl' (flip setDelete) set keys++setUnions :: IsSet set => [set] -> set+setUnions [] = setEmpty+setUnions sets = foldl1' setUnion sets+++class IsMap map where+ type KeyOf map++ mapNull :: map a -> Bool+ mapSize :: map a -> Int+ mapMember :: KeyOf map -> map a -> Bool+ mapLookup :: KeyOf map -> map a -> Maybe a+ mapFindWithDefault :: a -> KeyOf map -> map a -> a++ mapEmpty :: map a+ mapSingleton :: KeyOf map -> a -> map a+ mapInsert :: KeyOf map -> a -> map a -> map a+ mapInsertWith :: (a -> a -> a) -> KeyOf map -> a -> map a -> map a+ mapDelete :: KeyOf map -> map a -> map a++ mapUnion :: map a -> map a -> map a+ mapUnionWithKey :: (KeyOf map -> a -> a -> a) -> map a -> map a -> map a+ mapDifference :: map a -> map a -> map a+ mapIntersection :: map a -> map a -> map a+ mapIsSubmapOf :: Eq a => map a -> map a -> Bool++ mapMap :: (a -> b) -> map a -> map b+ mapMapWithKey :: (KeyOf map -> a -> b) -> map a -> map b+ mapFold :: (a -> b -> b) -> b -> map a -> b+ mapFoldWithKey :: (KeyOf map -> a -> b -> b) -> b -> map a -> b+ mapFilter :: (a -> Bool) -> map a -> map a++ mapElems :: map a -> [a]+ mapKeys :: map a -> [KeyOf map]+ mapToList :: map a -> [(KeyOf map, a)]+ mapFromList :: [(KeyOf map, a)] -> map a+ mapFromListWith :: (a -> a -> a) -> [(KeyOf map,a)] -> map a++-- Helper functions for IsMap class+mapInsertList :: IsMap map => [(KeyOf map, a)] -> map a -> map a+mapInsertList assocs map = foldl' (flip (uncurry mapInsert)) map assocs++mapDeleteList :: IsMap map => [KeyOf map] -> map a -> map a+mapDeleteList keys map = foldl' (flip mapDelete) map keys++mapUnions :: IsMap map => [map a] -> map a+mapUnions [] = mapEmpty+mapUnions maps = foldl1' mapUnion maps
cmm/Hoopl/Dataflow.hs view
@@ -21,26 +21,38 @@ ( C, O, Block , lastNode, entryLabel , foldNodesBwdOO- , DataflowLattice(..), OldFact(..), NewFact(..), JoinedFact(..), TransferFun+ , foldRewriteNodesBwdOO+ , DataflowLattice(..), OldFact(..), NewFact(..), JoinedFact(..)+ , TransferFun, RewriteFun , Fact, FactBase , getFact, mkFactBase , analyzeCmmFwd, analyzeCmmBwd+ , rewriteCmmBwd , changedIf , joinOutFacts ) where +import GhcPrelude+ import Cmm+import UniqSupply import Data.Array import Data.List import Data.Maybe+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet --- Hide definitions from Hoopl's Dataflow module.-import Compiler.Hoopl hiding ( DataflowLattice, OldFact, NewFact, JoinFun- , fact_bot, fact_join, joinOutFacts, mkFactBase- )+import Hoopl.Block+import Hoopl.Graph+import Hoopl.Collections+import Hoopl.Label +type family Fact x f :: *+type instance Fact C f = FactBase f+type instance Fact O f = f+ newtype OldFact a = OldFact a newtype NewFact a = NewFact a@@ -69,6 +81,14 @@ type TransferFun f = CmmBlock -> FactBase f -> FactBase f +-- | Function for rewrtiting and analysis combined. To be used with+-- @rewriteCmm@.+--+-- Currently set to work with @UniqSM@ monad, but we could probably abstract+-- that away (if we do that, we might want to specialize the fixpoint algorithms+-- to the particular monads through SPECIALIZE).+type RewriteFun f = CmmBlock -> FactBase f -> UniqSM (CmmBlock, FactBase f)+ analyzeCmmBwd, analyzeCmmFwd :: DataflowLattice f -> TransferFun f@@ -132,8 +152,76 @@ (updateFact join dep_blocks) (todo1, fbase1) out_facts in loop todo2 fbase2 +rewriteCmmBwd+ :: DataflowLattice f+ -> RewriteFun f+ -> CmmGraph+ -> FactBase f+ -> UniqSM (CmmGraph, FactBase f)+rewriteCmmBwd = rewriteCmm Bwd +rewriteCmm+ :: Direction+ -> DataflowLattice f+ -> RewriteFun f+ -> CmmGraph+ -> FactBase f+ -> UniqSM (CmmGraph, FactBase f)+rewriteCmm dir lattice rwFun cmmGraph initFact = do+ let entry = g_entry cmmGraph+ hooplGraph = g_graph cmmGraph+ blockMap1 =+ case hooplGraph of+ GMany NothingO bm NothingO -> bm+ entries = if mapNull initFact then [entry] else mapKeys initFact+ (blockMap2, facts) <-+ fixpointRewrite dir lattice rwFun entries blockMap1 initFact+ return (cmmGraph {g_graph = GMany NothingO blockMap2 NothingO}, facts) +fixpointRewrite+ :: forall f.+ Direction+ -> DataflowLattice f+ -> RewriteFun f+ -> [Label]+ -> LabelMap CmmBlock+ -> FactBase f+ -> UniqSM (LabelMap CmmBlock, FactBase f)+fixpointRewrite dir lattice do_block entries blockmap = loop start blockmap+ where+ -- Sorting the blocks helps to minimize the number of times we need to+ -- process blocks. For instance, for forward analysis we want to look at+ -- blocks in reverse postorder. Also, see comments for sortBlocks.+ blocks = sortBlocks dir entries blockmap+ num_blocks = length blocks+ block_arr = {-# SCC "block_arr_rewrite" #-}+ listArray (0, num_blocks - 1) blocks+ start = {-# SCC "start_rewrite" #-} [0 .. num_blocks - 1]+ dep_blocks = {-# SCC "dep_blocks_rewrite" #-} mkDepBlocks dir blocks+ join = fact_join lattice++ loop+ :: IntHeap -- ^ Worklist, i.e., blocks to process+ -> LabelMap CmmBlock -- ^ Rewritten blocks.+ -> FactBase f -- ^ Current facts.+ -> UniqSM (LabelMap CmmBlock, FactBase f)+ loop [] !blocks1 !fbase1 = return (blocks1, fbase1)+ loop (index : todo1) !blocks1 !fbase1 = do+ -- Note that we use the *original* block here. This is important.+ -- We're optimistically rewriting blocks even before reaching the fixed+ -- point, which means that the rewrite might be incorrect. So if the+ -- facts change, we need to rewrite the original block again (taking+ -- into account the new facts).+ let block = block_arr ! index+ (new_block, out_facts) <- {-# SCC "do_block_rewrite" #-}+ do_block block fbase1+ let blocks2 = mapInsert (entryLabel new_block) new_block blocks1+ (todo2, fbase2) = {-# SCC "mapFoldWithKey_rewrite" #-}+ mapFoldWithKey+ (updateFact join dep_blocks) (todo1, fbase1) out_facts+ loop todo2 blocks2 fbase2++ {- Note [Unreachable blocks] ~~~~~~~~~~~~~~~~~~~~~~~~~@@ -215,42 +303,52 @@ -- reverse of what is used for the forward one. --- | construct a mapping from L -> block indices. If the fact for L--- changes, re-analyse the given blocks.-mkDepBlocks :: NonLocal n => Direction -> [Block n C C] -> LabelMap [Int]+-- | Construct a mapping from a @Label@ to the block indexes that should be+-- re-analyzed if the facts at that @Label@ change.+--+-- Note that we're considering here the entry point of the block, so if the+-- facts change at the entry:+-- * for a backward analysis we need to re-analyze all the predecessors, but+-- * for a forward analysis, we only need to re-analyze the current block+-- (and that will in turn propagate facts into its successors).+mkDepBlocks :: Direction -> [CmmBlock] -> LabelMap IntSet mkDepBlocks Fwd blocks = go blocks 0 mapEmpty- where go [] !_ m = m- go (b:bs) !n m = go bs (n+1) $! mapInsert (entryLabel b) [n] m+ where+ go [] !_ !dep_map = dep_map+ go (b:bs) !n !dep_map =+ go bs (n + 1) $ mapInsert (entryLabel b) (IntSet.singleton n) dep_map mkDepBlocks Bwd blocks = go blocks 0 mapEmpty- where go [] !_ m = m- go (b:bs) !n m = go bs (n+1) $! go' (successors b) m- where go' [] m = m- go' (l:ls) m = go' ls (mapInsertWith (++) l [n] m)-+ where+ go [] !_ !dep_map = dep_map+ go (b:bs) !n !dep_map =+ let insert m l = mapInsertWith IntSet.union l (IntSet.singleton n) m+ in go bs (n + 1) $ foldl' insert dep_map (successors b) -- | After some new facts have been generated by analysing a block, we -- fold this function over them to generate (a) a list of block -- indices to (re-)analyse, and (b) the new FactBase.----updateFact :: JoinFun f -> LabelMap [Int]- -> Label -> f -- out fact- -> (IntHeap, FactBase f)- -> (IntHeap, FactBase f)-+updateFact+ :: JoinFun f+ -> LabelMap IntSet+ -> Label+ -> f -- out fact+ -> (IntHeap, FactBase f)+ -> (IntHeap, FactBase f) updateFact fact_join dep_blocks lbl new_fact (todo, fbase) = case lookupFact lbl fbase of- Nothing -> let !z = mapInsert lbl new_fact fbase in (changed, z)- -- Note [no old fact]+ Nothing ->+ -- Note [No old fact]+ let !z = mapInsert lbl new_fact fbase in (changed, z) Just old_fact ->- case fact_join (OldFact old_fact) (NewFact new_fact) of- (NotChanged _) -> (todo, fbase)- (Changed f) -> let !z = mapInsert lbl f fbase in (changed, z)+ case fact_join (OldFact old_fact) (NewFact new_fact) of+ (NotChanged _) -> (todo, fbase)+ (Changed f) -> let !z = mapInsert lbl f fbase in (changed, z) where- changed = foldr insertIntHeap todo $- mapFindWithDefault [] lbl dep_blocks+ changed = IntSet.foldr insertIntHeap todo $+ mapFindWithDefault IntSet.empty lbl dep_blocks {--Note [no old fact]+Note [No old fact] We know that the new_fact is >= _|_, so we don't need to join. However, if the new fact is also _|_, and we have already analysed its block,@@ -304,6 +402,39 @@ go (BMiddle n) f = funOO n f go BNil f = f {-# INLINABLE foldNodesBwdOO #-}++-- | Folds backward over all the nodes of an open-open block and allows+-- rewriting them. The accumulator is both the block of nodes and @f@ (usually+-- dataflow facts).+-- Strict in both accumulated parts.+foldRewriteNodesBwdOO+ :: forall f.+ (CmmNode O O -> f -> UniqSM (Block CmmNode O O, f))+ -> Block CmmNode O O+ -> f+ -> UniqSM (Block CmmNode O O, f)+foldRewriteNodesBwdOO rewriteOO initBlock initFacts = go initBlock initFacts+ where+ go (BCons node1 block1) !fact1 = (rewriteOO node1 `comp` go block1) fact1+ go (BSnoc block1 node1) !fact1 = (go block1 `comp` rewriteOO node1) fact1+ go (BCat blockA1 blockB1) !fact1 = (go blockA1 `comp` go blockB1) fact1+ go (BMiddle node) !fact1 = rewriteOO node fact1+ go BNil !fact = return (BNil, fact)++ comp rew1 rew2 = \f1 -> do+ (b, f2) <- rew2 f1+ (a, !f3) <- rew1 f2+ let !c = joinBlocksOO a b+ return (c, f3)+ {-# INLINE comp #-}+{-# INLINABLE foldRewriteNodesBwdOO #-}++joinBlocksOO :: Block n O O -> Block n O O -> Block n O O+joinBlocksOO BNil b = b+joinBlocksOO b BNil = b+joinBlocksOO (BMiddle n) b = blockCons n b+joinBlocksOO b (BMiddle n) = blockSnoc b n+joinBlocksOO b1 b2 = BCat b1 b2 -- ----------------------------------------------------------------------------- -- a Heap of Int
+ cmm/Hoopl/Graph.hs view
@@ -0,0 +1,201 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+module Hoopl.Graph+ ( Body+ , Graph+ , Graph'(..)+ , NonLocal(..)+ , addBlock+ , bodyList+ , emptyBody+ , labelsDefined+ , mapGraph+ , mapGraphBlocks+ , postorder_dfs_from+ ) where+++import GhcPrelude++import Hoopl.Label+import Hoopl.Block+import Hoopl.Collections++-- | A (possibly empty) collection of closed/closed blocks+type Body n = LabelMap (Block n C C)++-- | @Body@ abstracted over @block@+type Body' block (n :: * -> * -> *) = LabelMap (block n C C)++-------------------------------+-- | Gives access to the anchor points for+-- nonlocal edges as well as the edges themselves+class NonLocal thing where+ entryLabel :: thing C x -> Label -- ^ The label of a first node or block+ successors :: thing e C -> [Label] -- ^ Gives control-flow successors++instance NonLocal n => NonLocal (Block n) where+ entryLabel (BlockCO f _) = entryLabel f+ entryLabel (BlockCC f _ _) = entryLabel f++ successors (BlockOC _ n) = successors n+ successors (BlockCC _ _ n) = successors n+++emptyBody :: Body' block n+emptyBody = mapEmpty++bodyList :: Body' block n -> [(Label,block n C C)]+bodyList body = mapToList body++addBlock :: NonLocal thing+ => thing C C -> LabelMap (thing C C)+ -> LabelMap (thing C C)+addBlock b body+ | mapMember lbl body = error $ "duplicate label " ++ show lbl ++ " in graph"+ | otherwise = mapInsert lbl b body+ where lbl = entryLabel b+++-- ---------------------------------------------------------------------------+-- Graph++-- | A control-flow graph, which may take any of four shapes (O/O,+-- O/C, C/O, C/C). A graph open at the entry has a single,+-- distinguished, anonymous entry point; if a graph is closed at the+-- entry, its entry point(s) are supplied by a context.+type Graph = Graph' Block++-- | @Graph'@ is abstracted over the block type, so that we can build+-- graphs of annotated blocks for example (Compiler.Hoopl.Dataflow+-- needs this).+data Graph' block (n :: * -> * -> *) e x where+ GNil :: Graph' block n O O+ GUnit :: block n O O -> Graph' block n O O+ GMany :: MaybeO e (block n O C)+ -> Body' block n+ -> MaybeO x (block n C O)+ -> Graph' block n e x+++-- -----------------------------------------------------------------------------+-- Mapping over graphs++-- | Maps over all nodes in a graph.+mapGraph :: (forall e x. n e x -> n' e x) -> Graph n e x -> Graph n' e x+mapGraph f = mapGraphBlocks (mapBlock f)++-- | Function 'mapGraphBlocks' enables a change of representation of blocks,+-- nodes, or both. It lifts a polymorphic block transform into a polymorphic+-- graph transform. When the block representation stabilizes, a similar+-- function should be provided for blocks.+mapGraphBlocks :: forall block n block' n' e x .+ (forall e x . block n e x -> block' n' e x)+ -> (Graph' block n e x -> Graph' block' n' e x)++mapGraphBlocks f = map+ where map :: Graph' block n e x -> Graph' block' n' e x+ map GNil = GNil+ map (GUnit b) = GUnit (f b)+ map (GMany e b x) = GMany (fmap f e) (mapMap f b) (fmap f x)++-- -----------------------------------------------------------------------------+-- Extracting Labels from graphs++labelsDefined :: forall block n e x . NonLocal (block n) => Graph' block n e x+ -> LabelSet+labelsDefined GNil = setEmpty+labelsDefined (GUnit{}) = setEmpty+labelsDefined (GMany _ body x) = mapFoldWithKey addEntry (exitLabel x) body+ where addEntry :: forall a. ElemOf LabelSet -> a -> LabelSet -> LabelSet+ addEntry label _ labels = setInsert label labels+ exitLabel :: MaybeO x (block n C O) -> LabelSet+ exitLabel NothingO = setEmpty+ exitLabel (JustO b) = setSingleton (entryLabel b)+++----------------------------------------------------------------++class LabelsPtr l where+ targetLabels :: l -> [Label]++instance NonLocal n => LabelsPtr (n e C) where+ targetLabels n = successors n++instance LabelsPtr Label where+ targetLabels l = [l]++instance LabelsPtr LabelSet where+ targetLabels = setElems++instance LabelsPtr l => LabelsPtr [l] where+ targetLabels = concatMap targetLabels++-- | This is the most important traversal over this data structure. It drops+-- unreachable code and puts blocks in an order that is good for solving forward+-- dataflow problems quickly. The reverse order is good for solving backward+-- dataflow problems quickly. The forward order is also reasonably good for+-- emitting instructions, except that it will not usually exploit Forrest+-- Baskett's trick of eliminating the unconditional branch from a loop. For+-- that you would need a more serious analysis, probably based on dominators, to+-- identify loop headers.+--+-- The ubiquity of 'postorder_dfs' is one reason for the ubiquity of the 'LGraph'+-- representation, when for most purposes the plain 'Graph' representation is+-- more mathematically elegant (but results in more complicated code).+--+-- Here's an easy way to go wrong! Consider+-- @+-- A -> [B,C]+-- B -> D+-- C -> D+-- @+-- Then ordinary dfs would give [A,B,D,C] which has a back ref from C to D.+-- Better to get [A,B,C,D]+++-- | Traversal: 'postorder_dfs' returns a list of blocks reachable+-- from the entry of enterable graph. The entry and exit are *not* included.+-- The list has the following property:+--+-- Say a "back reference" exists if one of a block's+-- control-flow successors precedes it in the output list+--+-- Then there are as few back references as possible+--+-- The output is suitable for use in+-- a forward dataflow problem. For a backward problem, simply reverse+-- the list. ('postorder_dfs' is sufficiently tricky to implement that+-- one doesn't want to try and maintain both forward and backward+-- versions.)++postorder_dfs_from_except :: forall block e . (NonLocal block, LabelsPtr e)+ => LabelMap (block C C) -> e -> LabelSet -> [block C C]+postorder_dfs_from_except blocks b visited =+ vchildren (get_children b) (\acc _visited -> acc) [] visited+ where+ vnode :: block C C -> ([block C C] -> LabelSet -> a) -> [block C C] -> LabelSet -> a+ vnode block cont acc visited =+ if setMember id visited then+ cont acc visited+ else+ let cont' acc visited = cont (block:acc) visited in+ vchildren (get_children block) cont' acc (setInsert id visited)+ where id = entryLabel block+ vchildren :: forall a. [block C C] -> ([block C C] -> LabelSet -> a) -> [block C C] -> LabelSet -> a+ vchildren bs cont acc visited = next bs acc visited+ where next children acc visited =+ case children of [] -> cont acc visited+ (b:bs) -> vnode b (next bs) acc visited+ get_children :: forall l. LabelsPtr l => l -> [block C C]+ get_children block = foldr add_id [] $ targetLabels block+ add_id id rst = case lookupFact id blocks of+ Just b -> b : rst+ Nothing -> rst++postorder_dfs_from+ :: (NonLocal block, LabelsPtr b) => LabelMap (block C C) -> b -> [block C C]+postorder_dfs_from blocks b = postorder_dfs_from_except blocks b setEmpty
+ cmm/Hoopl/Label.hs view
@@ -0,0 +1,124 @@+{-# LANGUAGE DeriveFoldable #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE TypeFamilies #-}+module Hoopl.Label+ ( Label+ , LabelMap+ , LabelSet+ , FactBase+ , lookupFact+ , uniqueToLbl+ ) where++import GhcPrelude++import Outputable++import Hoopl.Collections+-- TODO: This should really just use GHC's Unique and Uniq{Set,FM}+import Hoopl.Unique++import Unique (Uniquable(..))++-----------------------------------------------------------------------------+-- Label+-----------------------------------------------------------------------------++newtype Label = Label { lblToUnique :: Unique }+ deriving (Eq, Ord)++uniqueToLbl :: Unique -> Label+uniqueToLbl = Label++instance Show Label where+ show (Label n) = "L" ++ show n++instance Uniquable Label where+ getUnique label = getUnique (lblToUnique label)++instance Outputable Label where+ ppr label = ppr (getUnique label)++-----------------------------------------------------------------------------+-- LabelSet++newtype LabelSet = LS UniqueSet deriving (Eq, Ord, Show)++instance IsSet LabelSet where+ type ElemOf LabelSet = Label++ setNull (LS s) = setNull s+ setSize (LS s) = setSize s+ setMember (Label k) (LS s) = setMember k s++ setEmpty = LS setEmpty+ setSingleton (Label k) = LS (setSingleton k)+ setInsert (Label k) (LS s) = LS (setInsert k s)+ setDelete (Label k) (LS s) = LS (setDelete k s)++ setUnion (LS x) (LS y) = LS (setUnion x y)+ setDifference (LS x) (LS y) = LS (setDifference x y)+ setIntersection (LS x) (LS y) = LS (setIntersection x y)+ setIsSubsetOf (LS x) (LS y) = setIsSubsetOf x y++ setFold k z (LS s) = setFold (k . uniqueToLbl) z s++ setElems (LS s) = map uniqueToLbl (setElems s)+ setFromList ks = LS (setFromList (map lblToUnique ks))++-----------------------------------------------------------------------------+-- LabelMap++newtype LabelMap v = LM (UniqueMap v)+ deriving (Eq, Ord, Show, Functor, Foldable, Traversable)++instance IsMap LabelMap where+ type KeyOf LabelMap = Label++ mapNull (LM m) = mapNull m+ mapSize (LM m) = mapSize m+ mapMember (Label k) (LM m) = mapMember k m+ mapLookup (Label k) (LM m) = mapLookup k m+ mapFindWithDefault def (Label k) (LM m) = mapFindWithDefault def k m++ mapEmpty = LM mapEmpty+ mapSingleton (Label k) v = LM (mapSingleton k v)+ mapInsert (Label k) v (LM m) = LM (mapInsert k v m)+ mapInsertWith f (Label k) v (LM m) = LM (mapInsertWith f k v m)+ mapDelete (Label k) (LM m) = LM (mapDelete k m)++ mapUnion (LM x) (LM y) = LM (mapUnion x y)+ mapUnionWithKey f (LM x) (LM y) = LM (mapUnionWithKey (f . uniqueToLbl) x y)+ mapDifference (LM x) (LM y) = LM (mapDifference x y)+ mapIntersection (LM x) (LM y) = LM (mapIntersection x y)+ mapIsSubmapOf (LM x) (LM y) = mapIsSubmapOf x y++ mapMap f (LM m) = LM (mapMap f m)+ mapMapWithKey f (LM m) = LM (mapMapWithKey (f . uniqueToLbl) m)+ mapFold k z (LM m) = mapFold k z m+ mapFoldWithKey k z (LM m) = mapFoldWithKey (k . uniqueToLbl) z m+ mapFilter f (LM m) = LM (mapFilter f m)++ mapElems (LM m) = mapElems m+ mapKeys (LM m) = map uniqueToLbl (mapKeys m)+ mapToList (LM m) = [(uniqueToLbl k, v) | (k, v) <- mapToList m]+ mapFromList assocs = LM (mapFromList [(lblToUnique k, v) | (k, v) <- assocs])+ mapFromListWith f assocs = LM (mapFromListWith f [(lblToUnique k, v) | (k, v) <- assocs])++-----------------------------------------------------------------------------+-- Instances++instance Outputable LabelSet where+ ppr = ppr . setElems++instance Outputable a => Outputable (LabelMap a) where+ ppr = ppr . mapToList++-----------------------------------------------------------------------------+-- FactBase++type FactBase f = LabelMap f++lookupFact :: Label -> FactBase f -> Maybe f+lookupFact = mapLookup
+ cmm/Hoopl/Unique.hs view
@@ -0,0 +1,93 @@+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE DeriveFoldable #-}+{-# LANGUAGE TypeFamilies #-}+module Hoopl.Unique+ ( Unique+ , UniqueMap+ , UniqueSet+ , intToUnique+ ) where++import GhcPrelude++import qualified Data.IntMap as M+import qualified Data.IntSet as S++import Hoopl.Collections+++-----------------------------------------------------------------------------+-- Unique+-----------------------------------------------------------------------------++type Unique = Int++intToUnique :: Int -> Unique+intToUnique = id++-----------------------------------------------------------------------------+-- UniqueSet++newtype UniqueSet = US S.IntSet deriving (Eq, Ord, Show)++instance IsSet UniqueSet where+ type ElemOf UniqueSet = Unique++ setNull (US s) = S.null s+ setSize (US s) = S.size s+ setMember k (US s) = S.member k s++ setEmpty = US S.empty+ setSingleton k = US (S.singleton k)+ setInsert k (US s) = US (S.insert k s)+ setDelete k (US s) = US (S.delete k s)++ setUnion (US x) (US y) = US (S.union x y)+ setDifference (US x) (US y) = US (S.difference x y)+ setIntersection (US x) (US y) = US (S.intersection x y)+ setIsSubsetOf (US x) (US y) = S.isSubsetOf x y++ setFold k z (US s) = S.foldr k z s++ setElems (US s) = S.elems s+ setFromList ks = US (S.fromList ks)++-----------------------------------------------------------------------------+-- UniqueMap++newtype UniqueMap v = UM (M.IntMap v)+ deriving (Eq, Ord, Show, Functor, Foldable, Traversable)++instance IsMap UniqueMap where+ type KeyOf UniqueMap = Unique++ mapNull (UM m) = M.null m+ mapSize (UM m) = M.size m+ mapMember k (UM m) = M.member k m+ mapLookup k (UM m) = M.lookup k m+ mapFindWithDefault def k (UM m) = M.findWithDefault def k m++ mapEmpty = UM M.empty+ mapSingleton k v = UM (M.singleton k v)+ mapInsert k v (UM m) = UM (M.insert k v m)+ mapInsertWith f k v (UM m) = UM (M.insertWith f k v m)+ mapDelete k (UM m) = UM (M.delete k m)++ mapUnion (UM x) (UM y) = UM (M.union x y)+ mapUnionWithKey f (UM x) (UM y) = UM (M.unionWithKey (f . intToUnique) x y)+ mapDifference (UM x) (UM y) = UM (M.difference x y)+ mapIntersection (UM x) (UM y) = UM (M.intersection x y)+ mapIsSubmapOf (UM x) (UM y) = M.isSubmapOf x y++ mapMap f (UM m) = UM (M.map f m)+ mapMapWithKey f (UM m) = UM (M.mapWithKey (f . intToUnique) m)+ mapFold k z (UM m) = M.foldr k z m+ mapFoldWithKey k z (UM m) = M.foldrWithKey (k . intToUnique) z m+ mapFilter f (UM m) = UM (M.filter f m)++ mapElems (UM m) = M.elems m+ mapKeys (UM m) = M.keys m+ mapToList (UM m) = M.toList m+ mapFromList assocs = UM (M.fromList assocs)+ mapFromListWith f assocs = UM (M.fromListWith f assocs)
cmm/MkGraph.hs view
@@ -21,12 +21,16 @@ ) where +import GhcPrelude (($),Int,Bool,Eq(..)) -- avoid importing (<*>)+ import BlockId import Cmm import CmmCallConv import CmmSwitch (SwitchTargets) -import Compiler.Hoopl hiding (Unique, (<*>), mkFirst, mkMiddle, mkLast, mkLabel, mkBranch, Shape(..))+import Hoopl.Block+import Hoopl.Graph+import Hoopl.Label import DynFlags import FastString import ForeignCall@@ -37,7 +41,6 @@ import Control.Monad import Data.List import Data.Maybe-import Prelude (($),Int,Bool,Eq(..)) -- avoid importing (<*>) #include "HsVersions.h" @@ -183,7 +186,7 @@ mkNop = nilOL mkComment :: FastString -> CmmAGraph-#ifdef DEBUG+#if defined(DEBUG) -- SDM: generating all those comments takes time, this saved about 4% for me mkComment fs = mkMiddle $ CmmComment fs #else
cmm/PprC.hs view
@@ -26,12 +26,16 @@ #include "HsVersions.h" -- Cmm stuff+import GhcPrelude+ import BlockId import CLabel import ForeignCall import Cmm hiding (pprBBlock) import PprCmm ()-import Hoopl+import Hoopl.Block+import Hoopl.Collections+import Hoopl.Graph import CmmUtils import CmmSwitch @@ -62,17 +66,13 @@ -- -------------------------------------------------------------------------- -- Top level -pprCs :: DynFlags -> [RawCmmGroup] -> SDoc-pprCs dflags cmms- = pprCode CStyle (vcat $ map (\c -> split_marker $$ pprC c) cmms)- where- split_marker- | gopt Opt_SplitObjs dflags = text "__STG_SPLIT_MARKER"- | otherwise = empty+pprCs :: [RawCmmGroup] -> SDoc+pprCs cmms+ = pprCode CStyle (vcat $ map pprC cmms) writeCs :: DynFlags -> Handle -> [RawCmmGroup] -> IO () writeCs dflags handle cmms- = printForC dflags handle (pprCs dflags cmms)+ = printForC dflags handle (pprCs cmms) -- -------------------------------------------------------------------------- -- Now do some real work@@ -87,12 +87,13 @@ -- top level procs -- pprTop :: RawCmmDecl -> SDoc-pprTop (CmmProc infos clbl _ graph) =+pprTop (CmmProc infos clbl _in_live_regs graph) = (case mapLookup (g_entry graph) infos of Nothing -> empty- Just (Statics info_clbl info_dat) -> pprDataExterns info_dat $$- pprWordArray info_clbl info_dat) $$+ Just (Statics info_clbl info_dat) ->+ pprDataExterns info_dat $$+ pprWordArray info_is_in_rodata info_clbl info_dat) $$ (vcat [ blankLine, extern_decls,@@ -103,6 +104,8 @@ rbrace ] ) where+ -- info tables are always in .rodata+ info_is_in_rodata = True blocks = toBlockListEntryFirst graph (temp_decls, extern_decls) = pprTempAndExternDecls blocks @@ -111,21 +114,23 @@ -- We only handle (a) arrays of word-sized things and (b) strings. -pprTop (CmmData _section (Statics lbl [CmmString str])) =+pprTop (CmmData section (Statics lbl [CmmString str])) =+ pprExternDecl lbl $$ hcat [- pprLocalness lbl, text "char ", ppr lbl,+ pprLocalness lbl, pprConstness (isSecConstant section), text "char ", ppr lbl, text "[] = ", pprStringInCStyle str, semi ] -pprTop (CmmData _section (Statics lbl [CmmUninitialised size])) =+pprTop (CmmData section (Statics lbl [CmmUninitialised size])) =+ pprExternDecl lbl $$ hcat [- pprLocalness lbl, text "char ", ppr lbl,+ pprLocalness lbl, pprConstness (isSecConstant section), text "char ", ppr lbl, brackets (int size), semi ] -pprTop (CmmData _section (Statics lbl lits)) =+pprTop (CmmData section (Statics lbl lits)) = pprDataExterns lits $$- pprWordArray lbl lits+ pprWordArray (isSecConstant section) lbl lits -- -------------------------------------------------------------------------- -- BasicBlocks are self-contained entities: they always end in a jump.@@ -145,10 +150,12 @@ -- Info tables. Just arrays of words. -- See codeGen/ClosureInfo, and nativeGen/PprMach -pprWordArray :: CLabel -> [CmmStatic] -> SDoc-pprWordArray lbl ds+pprWordArray :: Bool -> CLabel -> [CmmStatic] -> SDoc+pprWordArray is_ro lbl ds = sdocWithDynFlags $ \dflags ->- hcat [ pprLocalness lbl, text "StgWord"+ -- TODO: align closures only+ pprExternDecl lbl $$+ hcat [ pprLocalness lbl, pprConstness is_ro, text "StgWord" , space, ppr lbl, text "[]" -- See Note [StgWord alignment] , pprAlignment (wordWidth dflags)@@ -184,6 +191,10 @@ pprLocalness lbl | not $ externallyVisibleCLabel lbl = text "static " | otherwise = empty +pprConstness :: Bool -> SDoc+pprConstness is_ro | is_ro = text "const "+ | otherwise = empty+ -- -------------------------------------------------------------------------- -- Statements. --@@ -712,6 +723,8 @@ (panic $ "PprC.pprMachOp_for_C: MO_VF_Quot" ++ " should have been handled earlier!") + MO_AlignmentCheck {} -> panic "-falignment-santisation not supported by unregisterised backend"+ signedOp :: MachOp -> Bool -- Argument type(s) are signed ints signedOp (MO_S_Quot _) = True signedOp (MO_S_Rem _) = True@@ -773,8 +786,11 @@ MO_Memcpy _ -> text "memcpy" MO_Memset _ -> text "memset" MO_Memmove _ -> text "memmove"+ MO_Memcmp _ -> text "memcmp" (MO_BSwap w) -> ptext (sLit $ bSwapLabel w) (MO_PopCnt w) -> ptext (sLit $ popCntLabel w)+ (MO_Pext w) -> ptext (sLit $ pextLabel w)+ (MO_Pdep w) -> ptext (sLit $ pdepLabel w) (MO_Clz w) -> ptext (sLit $ clzLabel w) (MO_Ctz w) -> ptext (sLit $ ctzLabel w) (MO_AtomicRMW w amop) -> ptext (sLit $ atomicRMWLabel w amop)@@ -988,31 +1004,38 @@ pprTempAndExternDecls :: [CmmBlock] -> (SDoc{-temps-}, SDoc{-externs-}) pprTempAndExternDecls stmts = (pprUFM (getUniqSet temps) (vcat . map pprTempDecl),- vcat (map (pprExternDecl False{-ToDo-}) (Map.keys lbls)))+ vcat (map pprExternDecl (Map.keys lbls))) where (temps, lbls) = runTE (mapM_ te_BB stmts) pprDataExterns :: [CmmStatic] -> SDoc pprDataExterns statics- = vcat (map (pprExternDecl False{-ToDo-}) (Map.keys lbls))+ = vcat (map pprExternDecl (Map.keys lbls)) where (_, lbls) = runTE (mapM_ te_Static statics) pprTempDecl :: LocalReg -> SDoc pprTempDecl l@(LocalReg _ rep) = hcat [ machRepCType rep, space, pprLocalReg l, semi ] -pprExternDecl :: Bool -> CLabel -> SDoc-pprExternDecl _in_srt lbl+pprExternDecl :: CLabel -> SDoc+pprExternDecl lbl -- do not print anything for "known external" things | not (needsCDecl lbl) = empty | Just sz <- foreignLabelStdcallInfo lbl = stdcall_decl sz | otherwise =- hcat [ visibility, label_type lbl,- lparen, ppr lbl, text ");" ]+ hcat [ visibility, label_type lbl , lparen, ppr lbl, text ");"+ -- occasionally useful to see label type+ -- , text "/* ", pprDebugCLabel lbl, text " */"+ ] where- label_type lbl | isBytesLabel lbl = text "B_"- | isForeignLabel lbl && isCFunctionLabel lbl = text "FF_"- | isCFunctionLabel lbl = text "F_"- | otherwise = text "I_"+ label_type lbl | isBytesLabel lbl = text "B_"+ | isForeignLabel lbl && isCFunctionLabel lbl+ = text "FF_"+ | isCFunctionLabel lbl = text "F_"+ | isStaticClosureLabel lbl = text "C_"+ -- generic .rodata labels+ | isSomeRODataLabel lbl = text "RO_"+ -- generic .data labels (common case)+ | otherwise = text "RW_" visibility | externallyVisibleCLabel lbl = char 'E'
cmm/PprCmm.hs view
@@ -39,6 +39,8 @@ ) where +import GhcPrelude hiding (succ)+ import BlockId () import CLabel import Cmm@@ -53,9 +55,8 @@ import PprCore () import BasicTypes-import Compiler.Hoopl-import Data.List-import Prelude hiding (succ)+import Hoopl.Block+import Hoopl.Graph ------------------------------------------------- -- Outputable instances
cmm/PprCmmDecl.hs view
@@ -40,6 +40,8 @@ ) where +import GhcPrelude+ import PprCmmExpr import Cmm
cmm/PprCmmExpr.hs view
@@ -38,6 +38,8 @@ ) where +import GhcPrelude+ import CmmExpr import Outputable
cmm/SMRep.hs view
@@ -9,7 +9,7 @@ -- * Words and bytes WordOff, ByteOff, wordsToBytes, bytesToWordsRoundUp,- roundUpToWords,+ roundUpToWords, roundUpTo, StgWord, fromStgWord, toStgWord, StgHalfWord, fromStgHalfWord, toStgHalfWord,@@ -50,6 +50,9 @@ #include "../HsVersions.h" #include "MachDeps.h" +import GhcPrelude++import BasicTypes( ConTagZ ) import DynFlags import Outputable import Platform@@ -76,9 +79,12 @@ -- | Round up the given byte count to the next byte count that's a -- multiple of the machine's word size. roundUpToWords :: DynFlags -> ByteOff -> ByteOff-roundUpToWords dflags n =- (n + (wORD_SIZE dflags - 1)) .&. (complement (wORD_SIZE dflags - 1))+roundUpToWords dflags n = roundUpTo n (wORD_SIZE dflags) +-- | Round up @base@ to a multiple of @size@.+roundUpTo :: ByteOff -> ByteOff -> ByteOff+roundUpTo base size = (base + (size - 1)) .&. (complement (size - 1))+ -- | Convert the given number of words to a number of bytes. -- -- This function morally has type @WordOff -> ByteOff@, but uses @Num@@ -185,14 +191,13 @@ -- rtsClosureType below. data ClosureTypeInfo- = Constr ConstrTag ConstrDescription+ = Constr ConTagZ ConstrDescription | Fun FunArity ArgDescr | Thunk | ThunkSelector SelectorOffset | BlackHole | IndStatic -type ConstrTag = Int type ConstrDescription = [Word8] -- result of dataConIdentity type FunArity = Int type SelectorOffset = Int
codeGen/CgUtils.hs view
@@ -12,9 +12,12 @@ #include "HsVersions.h" +import GhcPrelude+ import CodeGen.Platform import Cmm-import Hoopl+import Hoopl.Block+import Hoopl.Graph import CmmUtils import CLabel import DynFlags
codeGen/CodeGen/Platform.hs view
@@ -3,6 +3,8 @@ (callerSaves, activeStgRegs, haveRegBase, globalRegMaybe, freeReg) where +import GhcPrelude+ import CmmExpr import Platform import Reg
codeGen/CodeGen/Platform/ARM.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.ARM where +import GhcPrelude+ #define MACHREGS_NO_REGS 0 #define MACHREGS_arm 1 #include "CodeGen.Platform.hs"
codeGen/CodeGen/Platform/ARM64.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.ARM64 where +import GhcPrelude+ #define MACHREGS_NO_REGS 0 #define MACHREGS_aarch64 1 #include "CodeGen.Platform.hs"
codeGen/CodeGen/Platform/NoRegs.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.NoRegs where +import GhcPrelude+ #define MACHREGS_NO_REGS 1 #include "CodeGen.Platform.hs"
codeGen/CodeGen/Platform/PPC.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.PPC where +import GhcPrelude+ #define MACHREGS_NO_REGS 0 #define MACHREGS_powerpc 1 #include "CodeGen.Platform.hs"
codeGen/CodeGen/Platform/PPC_Darwin.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.PPC_Darwin where +import GhcPrelude+ #define MACHREGS_NO_REGS 0 #define MACHREGS_powerpc 1 #define MACHREGS_darwin 1
codeGen/CodeGen/Platform/SPARC.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.SPARC where +import GhcPrelude+ #define MACHREGS_NO_REGS 0 #define MACHREGS_sparc 1 #include "CodeGen.Platform.hs"
codeGen/CodeGen/Platform/X86.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.X86 where +import GhcPrelude+ #define MACHREGS_NO_REGS 0 #define MACHREGS_i386 1 #include "CodeGen.Platform.hs"
codeGen/CodeGen/Platform/X86_64.hs view
@@ -2,6 +2,8 @@ module CodeGen.Platform.X86_64 where +import GhcPrelude+ #define MACHREGS_NO_REGS 0 #define MACHREGS_x86_64 1 #include "CodeGen.Platform.hs"
codeGen/StgCmm.hs view
@@ -12,6 +12,8 @@ #include "HsVersions.h" +import GhcPrelude as Prelude+ import StgCmmProf (initCostCentres, ldvEnter) import StgCmmMonad import StgCmmEnv@@ -160,39 +162,6 @@ -- Module initialisation code --------------------------------------------------------------- -{- The module initialisation code looks like this, roughly:-- FN(__stginit_Foo) {- JMP_(__stginit_Foo_1_p)- }-- FN(__stginit_Foo_1_p) {- ...- }-- We have one version of the init code with a module version and the- 'way' attached to it. The version number helps to catch cases- where modules are not compiled in dependency order before being- linked: if a module has been compiled since any modules which depend on- it, then the latter modules will refer to a different version in their- init blocks and a link error will ensue.-- The 'way' suffix helps to catch cases where modules compiled in different- ways are linked together (eg. profiled and non-profiled).-- We provide a plain, unadorned, version of the module init code- which just jumps to the version with the label and way attached. The- reason for this is that when using foreign exports, the caller of- startupHaskell() must supply the name of the init function for the "top"- module in the program, and we don't want to require that this name- has the version and way info appended to it.--We initialise the module tree by keeping a work-stack,- * pointed to by Sp- * that grows downward- * Sp points to the last occupied slot--}- mkModuleInit :: CollectedCCs -- cost centre info -> Module@@ -202,10 +171,6 @@ mkModuleInit cost_centre_info this_mod hpc_info = do { initHpc this_mod hpc_info ; initCostCentres cost_centre_info- -- For backwards compatibility: user code may refer to this- -- label for calling hs_add_root().- ; let lbl = mkPlainModuleInitLabel this_mod- ; emitDecl (CmmData (Section Data lbl) (Statics lbl [])) } @@ -270,8 +235,8 @@ | gopt Opt_SplitObjs dflags, -- See Note [Externalise when splitting] -- in StgCmmMonad isInternalName name = do { mod <- getModuleName- ; returnFC (setIdName id (externalise mod)) }- | otherwise = returnFC id+ ; return (setIdName id (externalise mod)) }+ | otherwise = return id where externalise mod = mkExternalName uniq mod new_occ loc name = idName id
codeGen/StgCmmArgRep.hs view
@@ -15,6 +15,8 @@ ) where +import GhcPrelude+ import StgCmmClosure ( idPrimRep ) import SMRep ( WordOff )
codeGen/StgCmmBind.hs view
@@ -17,6 +17,8 @@ #include "HsVersions.h" +import GhcPrelude hiding ((<*>))+ import StgCmmExpr import StgCmmMonad import StgCmmEnv@@ -53,8 +55,6 @@ import Control.Monad -import Prelude hiding ((<*>))- ------------------------------------------------------------------------ -- Top-level bindings ------------------------------------------------------------------------@@ -112,7 +112,7 @@ -- BUILD THE OBJECT, AND GENERATE INFO TABLE (IF NECESSARY) ; emitDataLits closure_label closure_rep- ; let fv_details :: [(NonVoid Id, VirtualHpOffset)]+ ; let fv_details :: [(NonVoid Id, ByteOff)] (_, _, fv_details) = mkVirtHeapOffsets dflags (isLFThunk lf_info) [] -- Don't drop the non-void args until the closure info has been made ; forkClosureBody (closureCodeBody True id closure_info ccs
codeGen/StgCmmClosure.hs view
@@ -13,7 +13,6 @@ module StgCmmClosure ( DynTag, tagForCon, isSmallFamily,- ConTagZ, dataConTagZ, idPrimRep, isVoidRep, isGcPtrRep, addIdReps, addArgReps, argPrimRep,@@ -67,6 +66,8 @@ #include "HsVersions.h" +import GhcPrelude+ import StgSyn import SMRep import Cmm@@ -360,18 +361,18 @@ isSmallFamily :: DynFlags -> Int -> Bool isSmallFamily dflags fam_size = fam_size <= mAX_PTR_TAG dflags --- We keep the *zero-indexed* tag in the srt_len field of the info--- table of a data constructor.-dataConTagZ :: DataCon -> ConTagZ-dataConTagZ con = dataConTag con - fIRST_TAG+-- | Faster version of isSmallFamily if you haven't computed the size yet.+isSmallFamilyTyCon :: DynFlags -> TyCon -> Bool+isSmallFamilyTyCon dflags tycon =+ tyConFamilySizeAtMost tycon (mAX_PTR_TAG dflags) tagForCon :: DynFlags -> DataCon -> DynTag tagForCon dflags con- | isSmallFamily dflags fam_size = con_tag + 1- | otherwise = 1+ | isSmallFamilyTyCon dflags tycon = con_tag+ | otherwise = 1 where- con_tag = dataConTagZ con- fam_size = tyConFamilySize (dataConTyCon con)+ con_tag = dataConTag con -- NB: 1-indexed+ tycon = dataConTyCon con tagForArity :: DynFlags -> RepArity -> DynTag tagForArity dflags arity@@ -411,7 +412,7 @@ lfClosureType :: LambdaFormInfo -> ClosureTypeInfo lfClosureType (LFReEntrant _ _ arity _ argd) = Fun arity argd lfClosureType (LFCon con) = Constr (dataConTagZ con)- (dataConIdentity con)+ (dataConIdentity con) lfClosureType (LFThunk _ _ _ is_sel _) = thunkClosureType is_sel lfClosureType _ = panic "lfClosureType" @@ -559,7 +560,7 @@ (Just (self_loop_id, block_id, args)) | gopt Opt_Loopification dflags , id == self_loop_id- , n_args - v_args == length args+ , args `lengthIs` (n_args - v_args) -- If these patterns match then we know that: -- * loopification optimisation is turned on -- * function is performing a self-recursive call in a tail position@@ -1050,6 +1051,8 @@ info_lbl = mkConInfoTableLabel name NoCafRefs sm_rep = mkHeapRep dflags is_static ptr_wds nonptr_wds cl_type cl_type = Constr (dataConTagZ data_con) (dataConIdentity data_con)+ -- We keep the *zero-indexed* tag in the srt_len field+ -- of the info table of a data constructor. prof | not (gopt Opt_SccProfilingOn dflags) = NoProfilingInfo | otherwise = ProfilingInfo ty_descr val_descr
codeGen/StgCmmCon.hs view
@@ -17,6 +17,8 @@ #include "HsVersions.h" +import GhcPrelude+ import StgSyn import CoreSyn ( AltCon(..) ) @@ -77,10 +79,17 @@ -- LAY IT OUT ; let+ is_thunk = False (tot_wds, -- #ptr_wds + #nonptr_wds ptr_wds, -- #ptr_wds- nv_args_w_offsets) = mkVirtConstrOffsets dflags (addArgReps args)+ nv_args_w_offsets) =+ mkVirtHeapOffsetsWithPadding dflags is_thunk (addArgReps args) + mk_payload (Padding len _) = return (CmmInt 0 (widthFromBytes len))+ mk_payload (FieldOff arg _) = do+ CmmLit lit <- getArgAmode arg+ return lit+ nonptr_wds = tot_wds - ptr_wds -- we're not really going to emit an info table, so having@@ -88,10 +97,8 @@ -- needs to poke around inside it. info_tbl = mkDataConInfoTable dflags con True ptr_wds nonptr_wds - get_lit (arg, _offset) = do { CmmLit lit <- getArgAmode arg- ; return lit } - ; payload <- mapM get_lit nv_args_w_offsets+ ; payload <- mapM mk_payload nv_args_w_offsets -- NB1: nv_args_w_offsets is sorted into ptrs then non-ptrs -- NB2: all the amodes should be Lits! -- TODO (osa): Why?@@ -262,7 +269,7 @@ -- The binding below forces the masking out of the tag bits -- when accessing the constructor field.- bind_arg :: (NonVoid Id, VirtualHpOffset) -> FCode (Maybe LocalReg)+ bind_arg :: (NonVoid Id, ByteOff) -> FCode (Maybe LocalReg) bind_arg (arg@(NonVoid b), offset) | isDeadBinder b = -- Do not load unused fields from objects to local variables.
codeGen/StgCmmEnv.hs view
@@ -24,6 +24,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TyCon import StgCmmMonad import StgCmmUtils
codeGen/StgCmmExpr.hs view
@@ -13,6 +13,8 @@ #include "HsVersions.h" +import GhcPrelude hiding ((<*>))+ import {-# SOURCE #-} StgCmmBind ( cgBind ) import StgCmmMonad@@ -51,8 +53,6 @@ import Control.Arrow (first) import Data.Function ( on ) -import Prelude hiding ((<*>))- ------------------------------------------------------------------------ -- cgExpr: the main function ------------------------------------------------------------------------@@ -304,6 +304,7 @@ ; (mb_deflt, branches) <- cgAlgAltRhss (NoGcInAlts,AssignedDirectly) (NonVoid bndr) alts+ -- See Note [GC for conditionals] ; emitSwitch tag_expr branches mb_deflt 0 (tyConFamilySize tycon - 1) ; return AssignedDirectly }@@ -469,7 +470,8 @@ ; let ret_bndrs = chooseReturnBndrs bndr alt_type alts alt_regs = map (idToReg dflags) ret_bndrs ; simple_scrut <- isSimpleScrut scrut alt_type- ; let do_gc | not simple_scrut = True+ ; let do_gc | is_cmp_op scrut = False -- See Note [GC for conditionals]+ | not simple_scrut = True | isSingleton alts = False | up_hp_usg > 0 = False | otherwise = True@@ -484,11 +486,29 @@ ; _ <- bindArgsToRegs ret_bndrs ; cgAlts (gc_plan,ret_kind) (NonVoid bndr) alt_type alts }+ where+ is_cmp_op (StgOpApp (StgPrimOp op) _ _) = isComparisonPrimOp op+ is_cmp_op _ = False +{- Note [GC for conditionals]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+For boolean conditionals it seems that we have always done NoGcInAlts.+That is, we have always done the GC check before the conditional.+This is enshrined in the special case for+ case tagToEnum# (a>b) of ...+See Note [case on bool] -{--Note [scrut sequel]+It's odd, and it's flagrantly inconsistent with the rules described+Note [Compiling case expressions]. However, after eliminating the+tagToEnum# (Trac #13397) we will have:+ case (a>b) of ...+Rather than make it behave quite differently, I am testing for a+comparison operator here in in the general case as well. +ToDo: figure out what the Right Rule should be.++Note [scrut sequel]+~~~~~~~~~~~~~~~~~~~ The job of the scrutinee is to assign its value(s) to alt_regs. Additionally, if we plan to do a heap-check in the alternatives (see Note [Compiling case expressions]), then we *must* retreat Hp to@@ -542,7 +562,7 @@ = assertNonVoidIds [bndr] chooseReturnBndrs _bndr (MultiValAlt n) [(_, ids, _)]- = ASSERT2(n == length ids, ppr n $$ ppr ids $$ ppr _bndr)+ = ASSERT2(ids `lengthIs` n, ppr n $$ ppr ids $$ ppr _bndr) assertNonVoidIds ids -- 'bndr' is not assigned! chooseReturnBndrs bndr (AlgAlt _) _alts@@ -596,13 +616,12 @@ branches' = [(tag+1,branch) | (tag,branch) <- branches] emitSwitch tag_expr branches' mb_deflt 1 fam_sz - else -- No, get tag from info table- do dflags <- getDynFlags- let -- Note that ptr _always_ has tag 1- -- when the family size is big enough- untagged_ptr = cmmRegOffB bndr_reg (-1)- tag_expr = getConstrTag dflags (untagged_ptr)- emitSwitch tag_expr branches mb_deflt 0 (fam_sz - 1)+ else -- No, get tag from info table+ let -- Note that ptr _always_ has tag 1+ -- when the family size is big enough+ untagged_ptr = cmmRegOffB bndr_reg (-1)+ tag_expr = getConstrTag dflags (untagged_ptr)+ in emitSwitch tag_expr branches mb_deflt 0 (fam_sz - 1) ; return AssignedDirectly }
codeGen/StgCmmExtCode.hs view
@@ -36,6 +36,8 @@ where +import GhcPrelude+ import qualified StgCmmMonad as F import StgCmmMonad (FCode, newUnique)
codeGen/StgCmmForeign.hs view
@@ -22,6 +22,8 @@ #include "HsVersions.h" +import GhcPrelude hiding( succ, (<*>) )+ import StgSyn import StgCmmProf (storeCurCCS, ccsType, curCCS) import StgCmmEnv@@ -47,8 +49,6 @@ import BasicTypes import Control.Monad--import Prelude hiding( succ, (<*>) ) ----------------------------------------------------------------------------- -- Code generation for Foreign Calls
codeGen/StgCmmHeap.hs view
@@ -24,6 +24,8 @@ #include "HsVersions.h" +import GhcPrelude hiding ((<*>))+ import StgSyn import CLabel import StgCmmLayout@@ -36,7 +38,7 @@ import MkGraph -import Hoopl+import Hoopl.Label import SMRep import BlockId import Cmm@@ -49,8 +51,6 @@ import FastString( mkFastString, fsLit ) import Panic( sorry ) -import Prelude hiding ((<*>))- import Control.Monad (when) import Data.Maybe (isJust) @@ -221,23 +221,10 @@ mkStaticClosure dflags info_lbl ccs payload padding static_link_field saved_info_field = [CmmLabel info_lbl] ++ staticProfHdr dflags ccs- ++ concatMap (padLitToWord dflags) payload+ ++ payload ++ padding ++ static_link_field ++ saved_info_field---- JD: Simon had ellided this padding, but without it the C back end asserts--- failure. Maybe it's a bad assertion, and this padding is indeed unnecessary?-padLitToWord :: DynFlags -> CmmLit -> [CmmLit]-padLitToWord dflags lit = lit : padding pad_length- where width = typeWidth (cmmLitType dflags lit)- pad_length = wORD_SIZE dflags - widthInBytes width :: Int-- padding n | n <= 0 = []- | n `rem` 2 /= 0 = CmmInt 0 W8 : padding (n-1)- | n `rem` 4 /= 0 = CmmInt 0 W16 : padding (n-2)- | n `rem` 8 /= 0 = CmmInt 0 W32 : padding (n-4)- | otherwise = CmmInt 0 W64 : padding (n-8) ----------------------------------------------------------- -- Heap overflow checking
codeGen/StgCmmHpc.hs view
@@ -8,6 +8,8 @@ module StgCmmHpc ( initHpc, mkTickBox ) where +import GhcPrelude+ import StgCmmMonad import MkGraph
codeGen/StgCmmLayout.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} -----------------------------------------------------------------------------@@ -17,7 +18,12 @@ slowCall, directCall, - mkVirtHeapOffsets, mkVirtConstrOffsets, mkVirtConstrSizes, getHpRelOffset,+ FieldOffOrPadding(..),+ mkVirtHeapOffsets,+ mkVirtHeapOffsetsWithPadding,+ mkVirtConstrOffsets,+ mkVirtConstrSizes,+ getHpRelOffset, ArgRep(..), toArgRep, argRepSizeW -- re-exported from StgCmmArgRep ) where@@ -25,7 +31,7 @@ #include "HsVersions.h" -import Prelude hiding ((<*>))+import GhcPrelude hiding ((<*>)) import StgCmmClosure import StgCmmEnv@@ -44,7 +50,7 @@ import CLabel import StgSyn import Id-import TyCon ( PrimRep(..) )+import TyCon ( PrimRep(..), primRepSizeB ) import BasicTypes ( RepArity ) import DynFlags import Module@@ -274,7 +280,7 @@ -> CLabel -> RepArity -> [(ArgRep,Maybe CmmExpr)] -> FCode ReturnKind direct_call caller call_conv lbl arity args- | debugIsOn && real_arity > length args -- Too few args+ | debugIsOn && args `lengthLessThan` real_arity -- Too few args = do -- Caller should ensure that there enough args! pprPanic "direct_call" $ text caller <+> ppr arity <+>@@ -387,26 +393,33 @@ hp_usg <- getHpUsage return (cmmRegOffW dflags hpReg (hpRel (realHp hp_usg) virtual_offset)) -mkVirtHeapOffsets+data FieldOffOrPadding a+ = FieldOff (NonVoid a) -- Something that needs an offset.+ ByteOff -- Offset in bytes.+ | Padding ByteOff -- Length of padding in bytes.+ ByteOff -- Offset in bytes.++mkVirtHeapOffsetsWithPadding :: DynFlags -> Bool -- True <=> is a thunk- -> [NonVoid (PrimRep,a)] -- Things to make offsets for- -> (WordOff, -- _Total_ number of words allocated- WordOff, -- Number of words allocated for *pointers*- [(NonVoid a, ByteOff)])+ -> [NonVoid (PrimRep, a)] -- Things to make offsets for+ -> ( WordOff -- Total number of words allocated+ , WordOff -- Number of words allocated for *pointers*+ , [FieldOffOrPadding a] -- Either an offset or padding.+ ) -- Things with their offsets from start of object in order of -- increasing offset; BUT THIS MAY BE DIFFERENT TO INPUT ORDER -- First in list gets lowest offset, which is initial offset + 1. ----- mkVirtHeapOffsets always returns boxed things with smaller offsets+-- mkVirtHeapOffsetsWithPadding always returns boxed things with smaller offsets -- than the unboxed things -mkVirtHeapOffsets dflags is_thunk things- = ASSERT(not (any (isVoidRep . fst . fromNonVoid) things))- ( bytesToWordsRoundUp dflags tot_bytes+mkVirtHeapOffsetsWithPadding dflags is_thunk things =+ ASSERT(not (any (isVoidRep . fst . fromNonVoid) things))+ ( tot_wds , bytesToWordsRoundUp dflags bytes_of_ptrs- , ptrs_w_offsets ++ non_ptrs_w_offsets+ , concat (ptrs_w_offsets ++ non_ptrs_w_offsets) ++ final_pad ) where hdr_words | is_thunk = thunkHdrSize dflags@@ -420,10 +433,58 @@ (tot_bytes, non_ptrs_w_offsets) = mapAccumL computeOffset bytes_of_ptrs non_ptrs - computeOffset bytes_so_far nv_thing- = (bytes_so_far + wordsToBytes dflags (argRepSizeW dflags (toArgRep rep)),- (NonVoid thing, hdr_bytes + bytes_so_far))- where (rep,thing) = fromNonVoid nv_thing+ tot_wds = bytesToWordsRoundUp dflags tot_bytes++ final_pad_size = tot_wds * word_size - tot_bytes+ final_pad+ | final_pad_size > 0 = [(Padding final_pad_size+ (hdr_bytes + tot_bytes))]+ | otherwise = []++ word_size = wORD_SIZE dflags++ computeOffset bytes_so_far nv_thing =+ (new_bytes_so_far, with_padding field_off)+ where+ (rep, thing) = fromNonVoid nv_thing++ -- Size of the field in bytes.+ !sizeB = primRepSizeB dflags rep++ -- Align the start offset (eg, 2-byte value should be 2-byte aligned).+ -- But not more than to a word.+ !align = min word_size sizeB+ !start = roundUpTo bytes_so_far align+ !padding = start - bytes_so_far++ -- Final offset is:+ -- size of header + bytes_so_far + padding+ !final_offset = hdr_bytes + bytes_so_far + padding+ !new_bytes_so_far = start + sizeB+ field_off = FieldOff (NonVoid thing) final_offset++ with_padding field_off+ | padding == 0 = [field_off]+ | otherwise = [ Padding padding (hdr_bytes + bytes_so_far)+ , field_off+ ]+++mkVirtHeapOffsets+ :: DynFlags+ -> Bool -- True <=> is a thunk+ -> [NonVoid (PrimRep,a)] -- Things to make offsets for+ -> (WordOff, -- _Total_ number of words allocated+ WordOff, -- Number of words allocated for *pointers*+ [(NonVoid a, ByteOff)])+mkVirtHeapOffsets dflags is_thunk things =+ ( tot_wds+ , ptr_wds+ , [ (field, offset) | (FieldOff field offset) <- things_offsets ]+ )+ where+ (tot_wds, ptr_wds, things_offsets) =+ mkVirtHeapOffsetsWithPadding dflags is_thunk things -- | Just like mkVirtHeapOffsets, but for constructors mkVirtConstrOffsets
codeGen/StgCmmMonad.hs view
@@ -11,9 +11,8 @@ module StgCmmMonad ( FCode, -- type - initC, runC, thenC, thenFC, listCs,- returnFC, fixC,- newUnique, newUniqSupply,+ initC, runC, fixC,+ newUnique, emitLabel, @@ -61,11 +60,12 @@ #include "HsVersions.h" +import GhcPrelude hiding( sequence, succ )+ import Cmm import StgCmmClosure import DynFlags-import Hoopl-import Maybes+import Hoopl.Collections import MkGraph import BlockId import CLabel@@ -74,6 +74,7 @@ import Id import VarEnv import OrdList+import BasicTypes( ConTagZ ) import Unique import UniqSupply import FastString@@ -81,10 +82,7 @@ import Control.Monad import Data.List-import Prelude hiding( sequence, succ ) -infixr 9 `thenC` -- Right-associative!-infixr 9 `thenFC` --------------------------------------------------------@@ -113,27 +111,30 @@ -------------------------------------------------------- -newtype FCode a = FCode (CgInfoDownwards -> CgState -> (# a, CgState #))+newtype FCode a = FCode { doFCode :: CgInfoDownwards -> CgState -> (a, CgState) } instance Functor FCode where- fmap f (FCode g) = FCode $ \i s -> case g i s of (# a, s' #) -> (# f a, s' #)+ fmap f (FCode g) = FCode $ \i s -> case g i s of (a, s') -> (f a, s') instance Applicative FCode where- pure = returnFC- (<*>) = ap+ pure val = FCode (\_info_down state -> (val, state))+ {-# INLINE pure #-}+ (<*>) = ap instance Monad FCode where- (>>=) = thenFC--{-# INLINE thenC #-}-{-# INLINE thenFC #-}-{-# INLINE returnFC #-}+ FCode m >>= k = FCode $+ \info_down state ->+ case m info_down state of+ (m_result, new_state) ->+ case k m_result of+ FCode kcode -> kcode info_down new_state+ {-# INLINE (>>=) #-} instance MonadUnique FCode where getUniqueSupplyM = cgs_uniqs <$> getState getUniqueM = FCode $ \_ st -> let (u, us') = takeUniqFromSupply (cgs_uniqs st)- in (# u, st { cgs_uniqs = us' } #)+ in (u, st { cgs_uniqs = us' }) initC :: IO CgState initC = do { uniqs <- mkSplitUniqSupply 'c'@@ -142,36 +143,10 @@ runC :: DynFlags -> Module -> CgState -> FCode a -> (a,CgState) runC dflags mod st fcode = doFCode fcode (initCgInfoDown dflags mod) st -returnFC :: a -> FCode a-returnFC val = FCode (\_info_down state -> (# val, state #))--thenC :: FCode () -> FCode a -> FCode a-thenC (FCode m) (FCode k) =- FCode $ \info_down state -> case m info_down state of- (# _,new_state #) -> k info_down new_state--listCs :: [FCode ()] -> FCode ()-listCs [] = return ()-listCs (fc:fcs) = do- fc- listCs fcs--thenFC :: FCode a -> (a -> FCode c) -> FCode c-thenFC (FCode m) k = FCode $- \info_down state ->- case m info_down state of- (# m_result, new_state #) ->- case k m_result of- FCode kcode -> kcode info_down new_state- fixC :: (a -> FCode a) -> FCode a-fixC fcode = FCode (- \info_down state ->- let- (v,s) = doFCode (fcode v) info_down state- in- (# v, s #)- )+fixC fcode = FCode $+ \info_down state -> let (v, s) = doFCode (fcode v) info_down state+ in (v, s) -------------------------------------------------------- -- The code generator environment@@ -288,8 +263,8 @@ -- -- Since this case is so common I decided to make it more explicit and -- robust by programming the sharing directly, rather than relying on--- the common-block elimiantor to catch it. This makes--- common-block-elimianteion an optional optimisation, and furthermore+-- the common-block eliminator to catch it. This makes+-- common-block-elimination an optional optimisation, and furthermore -- generates less code in the first place that we have to subsequently -- clean up. --@@ -431,10 +406,10 @@ -------------------------------------------------------- getState :: FCode CgState-getState = FCode $ \_info_down state -> (# state, state #)+getState = FCode $ \_info_down state -> (state, state) setState :: CgState -> FCode ()-setState state = FCode $ \_info_down _ -> (# (), state #)+setState state = FCode $ \_info_down _ -> ((), state) getHpUsage :: FCode HeapUsage getHpUsage = do@@ -474,7 +449,7 @@ withState :: FCode a -> CgState -> FCode (a,CgState) withState (FCode fcode) newstate = FCode $ \info_down state -> case fcode info_down newstate of- (# retval, state2 #) -> (# (retval,state2), state #)+ (retval, state2) -> ((retval,state2), state) newUniqSupply :: FCode UniqSupply newUniqSupply = do@@ -492,7 +467,7 @@ ------------------ getInfoDown :: FCode CgInfoDownwards-getInfoDown = FCode $ \info_down state -> (# info_down,state #)+getInfoDown = FCode $ \info_down state -> (info_down,state) getSelfLoop :: FCode (Maybe SelfLoopInfo) getSelfLoop = do@@ -512,11 +487,6 @@ withInfoDown :: FCode a -> CgInfoDownwards -> FCode a withInfoDown (FCode fcode) info_down = FCode $ \_ state -> fcode info_down state--doFCode :: FCode a -> CgInfoDownwards -> CgState -> (a,CgState)-doFCode (FCode fcode) info_down state =- case fcode info_down state of- (# a, s #) -> ( a, s ) -- ---------------------------------------------------------------------------- -- Get the current module name
codeGen/StgCmmPrim.hs view
@@ -17,6 +17,8 @@ #include "HsVersions.h" +import GhcPrelude hiding ((<*>))+ import StgCmmLayout import StgCmmForeign import StgCmmEnv@@ -44,10 +46,8 @@ import Outputable import Util -import Prelude hiding ((<*>))- import Data.Bits ((.&.), bit)-import Control.Monad (liftM, when)+import Control.Monad (liftM, when, unless) ------------------------------------------------------------------------ -- Primitive operations and foreign calls@@ -568,6 +568,10 @@ emitPrimOp _ [] SetByteArrayOp [ba,off,len,c] = doSetByteArrayOp ba off len c +-- Comparing byte arrays+emitPrimOp _ [res] CompareByteArraysOp [ba1,ba1_off,ba2,ba2_off,n] =+ doCompareByteArraysOp res ba1 ba1_off ba2 ba2_off n+ emitPrimOp _ [res] BSwap16Op [w] = emitBSwapCall res w W16 emitPrimOp _ [res] BSwap32Op [w] = emitBSwapCall res w W32 emitPrimOp _ [res] BSwap64Op [w] = emitBSwapCall res w W64@@ -580,6 +584,20 @@ emitPrimOp _ [res] PopCnt64Op [w] = emitPopCntCall res w W64 emitPrimOp dflags [res] PopCntOp [w] = emitPopCntCall res w (wordWidth dflags) +-- Parallel bit deposit+emitPrimOp _ [res] Pdep8Op [src, mask] = emitPdepCall res src mask W8+emitPrimOp _ [res] Pdep16Op [src, mask] = emitPdepCall res src mask W16+emitPrimOp _ [res] Pdep32Op [src, mask] = emitPdepCall res src mask W32+emitPrimOp _ [res] Pdep64Op [src, mask] = emitPdepCall res src mask W64+emitPrimOp dflags [res] PdepOp [src, mask] = emitPdepCall res src mask (wordWidth dflags)++-- Parallel bit extract+emitPrimOp _ [res] Pext8Op [src, mask] = emitPextCall res src mask W8+emitPrimOp _ [res] Pext16Op [src, mask] = emitPextCall res src mask W16+emitPrimOp _ [res] Pext32Op [src, mask] = emitPextCall res src mask W32+emitPrimOp _ [res] Pext64Op [src, mask] = emitPextCall res src mask W64+emitPrimOp dflags [res] PextOp [src, mask] = emitPextCall res src mask (wordWidth dflags)+ -- count leading zeros emitPrimOp _ [res] Clz8Op [w] = emitClzCall res w W8 emitPrimOp _ [res] Clz16Op [w] = emitClzCall res w W16@@ -619,7 +637,7 @@ emitPrimOp dflags [res] (VecPackOp vcat n w) es = do checkVecCompatibility dflags vcat n w- when (length es /= n) $+ when (es `lengthIsNot` n) $ panic "emitPrimOp: VecPackOp has wrong number of arguments" doVecPackOp (vecElemInjectCast dflags vcat w) ty zeros es res where@@ -637,7 +655,7 @@ emitPrimOp dflags res (VecUnpackOp vcat n w) [arg] = do checkVecCompatibility dflags vcat n w- when (length res /= n) $+ when (res `lengthIsNot` n) $ panic "emitPrimOp: VecUnpackOp has wrong number of results" doVecUnpackOp (vecElemProjectCast dflags vcat w) ty arg res where@@ -1720,6 +1738,60 @@ emit $ mkAssign (CmmLocal res_r) base -- ----------------------------------------------------------------------------+-- Comparing byte arrays++doCompareByteArraysOp :: LocalReg -> CmmExpr -> CmmExpr -> CmmExpr -> CmmExpr -> CmmExpr+ -> FCode ()+doCompareByteArraysOp res ba1 ba1_off ba2 ba2_off n = do+ dflags <- getDynFlags+ ba1_p <- assignTempE $ cmmOffsetExpr dflags (cmmOffsetB dflags ba1 (arrWordsHdrSize dflags)) ba1_off+ ba2_p <- assignTempE $ cmmOffsetExpr dflags (cmmOffsetB dflags ba2 (arrWordsHdrSize dflags)) ba2_off++ -- short-cut in case of equal pointers avoiding a costly+ -- subroutine call to the memcmp(3) routine; the Cmm logic below+ -- results in assembly code being generated for+ --+ -- cmpPrefix10 :: ByteArray# -> ByteArray# -> Int#+ -- cmpPrefix10 ba1 ba2 = compareByteArrays# ba1 0# ba2 0# 10#+ --+ -- that looks like+ --+ -- leaq 16(%r14),%rax+ -- leaq 16(%rsi),%rbx+ -- xorl %ecx,%ecx+ -- cmpq %rbx,%rax+ -- je l_ptr_eq+ --+ -- ; NB: the common case (unequal pointers) falls-through+ -- ; the conditional jump, and therefore matches the+ -- ; usual static branch prediction convention of modern cpus+ --+ -- subq $8,%rsp+ -- movq %rbx,%rsi+ -- movq %rax,%rdi+ -- movl $10,%edx+ -- xorl %eax,%eax+ -- call memcmp+ -- addq $8,%rsp+ -- movslq %eax,%rax+ -- movq %rax,%rcx+ -- l_ptr_eq:+ -- movq %rcx,%rbx+ -- jmp *(%rbp)++ l_ptr_eq <- newBlockId+ l_ptr_ne <- newBlockId++ emit (mkAssign (CmmLocal res) (zeroExpr dflags))+ emit (mkCbranch (cmmEqWord dflags ba1_p ba2_p)+ l_ptr_eq l_ptr_ne (Just False))++ emitLabel l_ptr_ne+ emitMemcmpCall res ba1_p ba2_p n 1++ emitLabel l_ptr_eq++-- ---------------------------------------------------------------------------- -- Copying byte arrays -- | Takes a source 'ByteArray#', an offset in the source array, a@@ -2213,6 +2285,30 @@ (MO_Memset align) [ dst, c, n ] +emitMemcmpCall :: LocalReg -> CmmExpr -> CmmExpr -> CmmExpr -> Int -> FCode ()+emitMemcmpCall res ptr1 ptr2 n align = do+ -- 'MO_Memcmp' is assumed to return an 32bit 'CInt' because all+ -- code-gens currently call out to the @memcmp(3)@ C function.+ -- This was easier than moving the sign-extensions into+ -- all the code-gens.+ dflags <- getDynFlags+ let is32Bit = typeWidth (localRegType res) == W32++ cres <- if is32Bit+ then return res+ else newTemp b32++ emitPrimCall+ [ cres ]+ (MO_Memcmp align)+ [ ptr1, ptr2, n ]++ unless is32Bit $ do+ emit $ mkAssign (CmmLocal res)+ (CmmMachOp+ (mo_s_32ToWord dflags)+ [(CmmReg (CmmLocal cres))])+ emitBSwapCall :: LocalReg -> CmmExpr -> Width -> FCode () emitBSwapCall res x width = do emitPrimCall@@ -2226,6 +2322,20 @@ [ res ] (MO_PopCnt width) [ x ]++emitPdepCall :: LocalReg -> CmmExpr -> CmmExpr -> Width -> FCode ()+emitPdepCall res x y width = do+ emitPrimCall+ [ res ]+ (MO_Pdep width)+ [ x, y ]++emitPextCall :: LocalReg -> CmmExpr -> CmmExpr -> Width -> FCode ()+emitPextCall res x y width = do+ emitPrimCall+ [ res ]+ (MO_Pext width)+ [ x, y ] emitClzCall :: LocalReg -> CmmExpr -> Width -> FCode () emitClzCall res x width = do
codeGen/StgCmmProf.hs view
@@ -27,6 +27,8 @@ #include "HsVersions.h" +import GhcPrelude+ import StgCmmClosure import StgCmmUtils import StgCmmMonad@@ -207,7 +209,7 @@ initCostCentres :: CollectedCCs -> FCode () -- Emit the declarations-initCostCentres (local_CCs, ___extern_CCs, singleton_CCSs)+initCostCentres (local_CCs, singleton_CCSs) = do dflags <- getDynFlags when (gopt Opt_SccProfilingOn dflags) $ do mapM_ emitCostCentreDecl local_CCs
codeGen/StgCmmTicky.hs view
@@ -106,6 +106,8 @@ #include "HsVersions.h" +import GhcPrelude+ import StgCmmArgRep ( slowCallPattern , toArgRep , argRepString ) import StgCmmClosure import StgCmmUtils@@ -124,6 +126,7 @@ import BasicTypes import FastString import Outputable+import Util import DynFlags @@ -381,7 +384,7 @@ -- Ticks at a *call site*: tickyDirectCall :: RepArity -> [StgArg] -> FCode () tickyDirectCall arity args- | arity == length args = tickyKnownCallExact+ | args `lengthIs` arity = tickyKnownCallExact | otherwise = do tickyKnownCallExtraArgs tickySlowCallPat (map argPrimRep (drop arity args)) @@ -412,7 +415,7 @@ tickySlowCallPat args = ifTicky $ let argReps = map toArgRep args (_, n_matched) = slowCallPattern argReps- in if n_matched > 0 && n_matched == length args+ in if n_matched > 0 && args `lengthIs` n_matched then bumpTickyLbl $ mkRtsSlowFastTickyCtrLabel $ concatMap (map Data.Char.toLower . argRepString) argReps else bumpTickyCounter $ fsLit "VERY_SLOW_CALL_ctr"
codeGen/StgCmmUtils.hs view
@@ -43,6 +43,8 @@ #include "HsVersions.h" +import GhcPrelude+ import StgCmmMonad import StgCmmClosure import Cmm@@ -399,8 +401,8 @@ unscramble :: DynFlags -> [Vrtx] -> FCode () unscramble dflags vertices = mapM_ do_component components where- edges :: [ (Vrtx, Key, [Key]) ]- edges = [ (vertex, key1, edges_from stmt1)+ edges :: [ Node Key Vrtx ]+ edges = [ DigraphNode vertex key1 (edges_from stmt1) | vertex@(key1, stmt1) <- vertices ] edges_from :: Stmt -> [Key]
coreSyn/CoreArity.hs view
@@ -18,6 +18,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreFVs import CoreUtils@@ -317,7 +319,7 @@ isn't a bad thing. Hence the ABot/ATop in ArityType. So these two transformations aren't always the Right Thing, and we-have several tickets reporting unexpected bahaviour resulting from+have several tickets reporting unexpected behaviour resulting from this transformation. So we try to limit it as much as possible: (1) Do NOT move a lambda outside a known-bottom case expression@@ -484,6 +486,10 @@ -- There is always an explicit lambda -- to justify the [OneShot], or the Arity +instance Outputable ArityType where+ ppr (ATop os) = text "ATop" <> parens (ppr (length os))+ ppr (ABot n) = text "ABot" <> parens (ppr n)+ vanillaArityType :: ArityType vanillaArityType = ATop [] -- Totally uninformative @@ -508,70 +514,69 @@ mk_cheap_fn :: DynFlags -> CheapAppFun -> CheapFun mk_cheap_fn dflags cheap_app | not (gopt Opt_DictsCheap dflags)- = \e _ -> exprIsOk cheap_app e+ = \e _ -> exprIsCheapX cheap_app e | otherwise- = \e mb_ty -> exprIsOk cheap_app e+ = \e mb_ty -> exprIsCheapX cheap_app e || case mb_ty of Nothing -> False Just ty -> isDictLikeTy ty -----------------------findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> Arity+findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> (Arity, Bool) -- This implements the fixpoint loop for arity analysis -- See Note [Arity analysis]+-- If findRhsArity e = (n, is_bot) then+-- (a) any application of e to <n arguments will not do much work,+-- so it is safe to expand e ==> (\x1..xn. e x1 .. xn)+-- (b) if is_bot=True, then e applied to n args is guaranteed bottom findRhsArity dflags bndr rhs old_arity- = go (rhsEtaExpandArity dflags init_cheap_app rhs)+ = go (get_arity init_cheap_app) -- We always call exprEtaExpandArity once, but usually -- that produces a result equal to old_arity, and then -- we stop right away (since arities should not decrease) -- Result: the common case is that there is just one iteration where+ is_lam = has_lam rhs++ has_lam (Tick _ e) = has_lam e+ has_lam (Lam b e) = isId b || has_lam e+ has_lam _ = False+ init_cheap_app :: CheapAppFun init_cheap_app fn n_val_args | fn == bndr = True -- On the first pass, this binder gets infinite arity | otherwise = isCheapApp fn n_val_args - go :: Arity -> Arity- go cur_arity- | cur_arity <= old_arity = cur_arity- | new_arity == cur_arity = cur_arity+ go :: (Arity, Bool) -> (Arity, Bool)+ go cur_info@(cur_arity, _)+ | cur_arity <= old_arity = cur_info+ | new_arity == cur_arity = cur_info | otherwise = ASSERT( new_arity < cur_arity )-#ifdef DEBUG+#if defined(DEBUG) pprTrace "Exciting arity" (vcat [ ppr bndr <+> ppr cur_arity <+> ppr new_arity- , ppr rhs])+ , ppr rhs]) #endif- go new_arity+ go new_info where- new_arity = rhsEtaExpandArity dflags cheap_app rhs+ new_info@(new_arity, _) = get_arity cheap_app cheap_app :: CheapAppFun cheap_app fn n_val_args | fn == bndr = n_val_args < cur_arity | otherwise = isCheapApp fn n_val_args --- ^ The Arity returned is the number of value args the--- expression can be applied to without doing much work-rhsEtaExpandArity :: DynFlags -> CheapAppFun -> CoreExpr -> Arity--- exprEtaExpandArity is used when eta expanding--- e ==> \xy -> e x y-rhsEtaExpandArity dflags cheap_app e- = case (arityType env e) of- ATop (os:oss)- | isOneShotInfo os || has_lam e -> 1 + length oss- -- Don't expand PAPs/thunks- -- Note [Eta expanding thunks]- | otherwise -> 0- ATop [] -> 0- ABot n -> n- where- env = AE { ae_cheap_fn = mk_cheap_fn dflags cheap_app- , ae_ped_bot = gopt Opt_PedanticBottoms dflags }-- has_lam (Tick _ e) = has_lam e- has_lam (Lam b e) = isId b || has_lam e- has_lam _ = False+ get_arity :: CheapAppFun -> (Arity, Bool)+ get_arity cheap_app+ = case (arityType env rhs) of+ ABot n -> (n, True)+ ATop (os:oss) | isOneShotInfo os || is_lam+ -> (1 + length oss, False) -- Don't expand PAPs/thunks+ ATop _ -> (0, False) -- Note [Eta expanding thunks]+ where+ env = AE { ae_cheap_fn = mk_cheap_fn dflags cheap_app+ , ae_ped_bot = gopt Opt_PedanticBottoms dflags } {- Note [Arity analysis]@@ -835,6 +840,33 @@ a subsequent clean-up phase of the Simplifier to de-crapify the result, means you can't really use it in CorePrep, which is painful. +Note [Eta expansion for join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The no-crap rule is very tiresome to guarantee when+we have join points. Consider eta-expanding+ let j :: Int -> Int -> Bool+ j x = e+ in b++The simple way is+ \(y::Int). (let j x = e in b) y++The no-crap way is+ \(y::Int). let j' :: Int -> Bool+ j' x = e y+ in b[j'/j] y+where I have written to stress that j's type has+changed. Note that (of course!) we have to push the application+inside the RHS of the join as well as into the body. AND if j+has an unfolding we have to push it into there too. AND j might+be recursive...++So for now I'm abandonig the no-crap rule in this case. I think+that for the use in CorePrep it really doesn't matter; and if+it does, then CoreToStg.myCollectArgs will fall over.++(Moreover, I think that casts can make the no-crap rule fail too.)+ Note [Eta expansion and SCCs] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Note that SCCs are not treated specially by etaExpand. If we have@@ -908,11 +940,11 @@ sexpr = foldl App expr'' args retick expr = foldr mkTick expr ticks - -- Wrapper Unwrapper+ -- Abstraction Application ---------------data EtaInfo = EtaVar Var -- /\a. [], [] a- -- \x. [], [] x- | EtaCo Coercion -- [] |> co, [] |> (sym co)+data EtaInfo = EtaVar Var -- /\a. [] [] a+ -- \x. [] [] x+ | EtaCo Coercion -- [] |> sym co [] |> co instance Outputable EtaInfo where ppr (EtaVar v) = text "EtaVar" <+> ppr v@@ -947,22 +979,21 @@ co' = CoreSubst.substCo subst co1 etaInfoApp subst (Case e b ty alts) eis- = Case (subst_expr subst e) b1 (mk_alts_ty (CoreSubst.substTy subst ty) eis) alts'+ = Case (subst_expr subst e) b1 ty' alts' where (subst1, b1) = substBndr subst b alts' = map subst_alt alts+ ty' = etaInfoAppTy (CoreSubst.substTy subst ty) eis subst_alt (con, bs, rhs) = (con, bs', etaInfoApp subst2 rhs eis) where (subst2,bs') = substBndrs subst1 bs - mk_alts_ty ty [] = ty- mk_alts_ty ty (EtaVar v : eis) = mk_alts_ty (applyTypeToArg ty (varToCoreExpr v)) eis- mk_alts_ty _ (EtaCo co : eis) = mk_alts_ty (pSnd (coercionKind co)) eis- etaInfoApp subst (Let b e) eis+ | not (isJoinBind b)+ -- See Note [Eta expansion for join points] = Let b' (etaInfoApp subst' e eis) where- (subst', b') = etaInfoAppBind subst b eis+ (subst', b') = substBindSC subst b etaInfoApp subst (Tick t e) eis = Tick (substTickish subst t) (etaInfoApp subst e eis)@@ -980,93 +1011,14 @@ go e (EtaVar v : eis) = go (App e (varToCoreExpr v)) eis go e (EtaCo co : eis) = go (Cast e co) eis ------------------ | Apply the eta info to a local binding. Mostly delegates to--- `etaInfoAppLocalBndr` and `etaInfoAppRhs`.-etaInfoAppBind :: Subst -> CoreBind -> [EtaInfo] -> (Subst, CoreBind)-etaInfoAppBind subst (NonRec bndr rhs) eis- = (subst', NonRec bndr' rhs')- where- bndr_w_new_type = etaInfoAppLocalBndr bndr eis- (subst', bndr1) = substBndr subst bndr_w_new_type- rhs' = etaInfoAppRhs subst bndr1 rhs eis- bndr' | isJoinId bndr = bndr1 `setIdArity` manifestArity rhs'- -- Arity may have changed- -- (see etaInfoAppRhs example)- | otherwise = bndr1-etaInfoAppBind subst (Rec pairs) eis- = (subst', Rec (bndrs' `zip` rhss'))- where- (bndrs, rhss) = unzip pairs- bndrs_w_new_types = map (\bndr -> etaInfoAppLocalBndr bndr eis) bndrs- (subst', bndrs1) = substRecBndrs subst bndrs_w_new_types- rhss' = zipWith process bndrs1 rhss- process bndr' rhs = etaInfoAppRhs subst' bndr' rhs eis- bndrs' | isJoinId (head bndrs)- = [ bndr1 `setIdArity` manifestArity rhs'- | (bndr1, rhs') <- bndrs1 `zip` rhss' ]- -- Arities may have changed- -- (see etaInfoAppRhs example)- | otherwise- = bndrs1 ----------------- | Apply the eta info to a binder's RHS. Only interesting for a join point,--- where we might have this:--- join j :: a -> [a] -> [a]--- j x = \xs -> x : xs in jump j z--- Eta-expanding produces this:--- \ys -> (join j :: a -> [a] -> [a]--- j x = \xs -> x : xs in jump j z) ys--- Now when we push the application to ys inward (see Note [No crap in--- eta-expanded code]), it goes to the body of the RHS of the join point (after--- the lambda x!):--- \ys -> join j :: a -> [a]--- j x = x : ys in jump j z--- Note that the type and arity of j have both changed.-etaInfoAppRhs :: Subst -> CoreBndr -> CoreExpr -> [EtaInfo] -> CoreExpr-etaInfoAppRhs subst bndr expr eis- | Just arity <- isJoinId_maybe bndr- = do_join_point arity- | otherwise- = subst_expr subst expr- where- do_join_point arity = mkLams join_bndrs' join_body'- where- (join_bndrs, join_body) = collectNBinders arity expr- (subst', join_bndrs') = substBndrs subst join_bndrs- join_body' = etaInfoApp subst' join_body eis-------------------- | Apply the eta info to a local binder. A join point will have the EtaInfos--- applied to its RHS, so its type may change. See comment on etaInfoAppRhs for--- an example. See Note [No crap in eta-expanded code] for why all this is--- necessary.-etaInfoAppLocalBndr :: CoreBndr -> [EtaInfo] -> CoreBndr-etaInfoAppLocalBndr bndr orig_eis- = case isJoinId_maybe bndr of- Just arity -> bndr `setIdType` modifyJoinResTy arity (app orig_eis) ty- Nothing -> bndr- where- ty = idType bndr-- -- | Apply the given EtaInfos to the result type of the join point.- app :: [EtaInfo] -- To apply- -> Type -- Result type of join point- -> Type -- New result type- app [] ty- = ty- app (EtaVar v : eis) ty- | isId v = app eis (funResultTy ty)- | otherwise = app eis (piResultTy ty (mkTyVarTy v))- app (EtaCo co : eis) ty- = ASSERT2(from_ty `eqType` ty, fsep ([text "can't apply", ppr orig_eis,- text "to", ppr bndr <+> dcolon <+>- ppr (idType bndr)]))- app eis to_ty- where- Pair from_ty to_ty = coercionKind co+etaInfoAppTy :: Type -> [EtaInfo] -> Type+-- If e :: ty+-- then etaInfoApp e eis :: etaInfoApp ty eis+etaInfoAppTy ty [] = ty+etaInfoAppTy ty (EtaVar v : eis) = etaInfoAppTy (applyTypeToArg ty (varToCoreExpr v)) eis+etaInfoAppTy _ (EtaCo co : eis) = etaInfoAppTy (pSnd (coercionKind co)) eis -------------- mkEtaWW :: Arity -> CoreExpr -> InScopeSet -> Type@@ -1106,7 +1058,7 @@ -- eta_expand 1 e T -- We want to get -- coerce T (\x::[T] -> (coerce ([T]->Int) e) x)- go n subst ty' (EtaCo co : eis)+ go n subst ty' (pushCoercion co eis) | otherwise -- We have an expression of arity > 0, -- but its type isn't a function, or a binder
coreSyn/CoreFVs.hs view
@@ -55,20 +55,19 @@ freeVars, -- CoreExpr -> CoreExprWithFVs freeVarsBind, -- CoreBind -> DVarSet -> (DVarSet, CoreBindWithFVs) freeVarsOf, -- CoreExprWithFVs -> DIdSet- freeVarsOfType, -- CoreExprWithFVs -> TyCoVarSet- freeVarsOfAnn, freeVarsOfTypeAnn,- exprTypeFV -- CoreExprWithFVs -> Type+ freeVarsOfAnn ) where #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import Id import IdInfo import NameSet import UniqSet import Unique (Uniquable (..))-import Literal ( literalType ) import Name import VarSet import Var@@ -78,7 +77,6 @@ import CoAxiom import FamInstEnv import TysPrim( funTyConName )-import Coercion import Maybes( orElse ) import Util import BasicTypes( Activation )@@ -388,13 +386,13 @@ orphNamesOfCo (KindCo co) = orphNamesOfCo co orphNamesOfCo (SubCo co) = orphNamesOfCo co orphNamesOfCo (AxiomRuleCo _ cs) = orphNamesOfCos cs+orphNamesOfCo (HoleCo _) = emptyNameSet orphNamesOfProv :: UnivCoProvenance -> NameSet orphNamesOfProv UnsafeCoerceProv = emptyNameSet orphNamesOfProv (PhantomProv co) = orphNamesOfCo co orphNamesOfProv (ProofIrrelProv co) = orphNamesOfCo co orphNamesOfProv (PluginProv _) = emptyNameSet-orphNamesOfProv (HoleProv _) = emptyNameSet orphNamesOfCos :: [Coercion] -> NameSet orphNamesOfCos = orphNamesOfThings orphNamesOfCo@@ -539,10 +537,7 @@ NON-GLOBAL free variables and type variables. -} -data FVAnn = FVAnn { fva_fvs :: DVarSet -- free in expression- , fva_ty_fvs :: DVarSet -- free only in expression's type- , fva_ty :: Type -- expression's type- }+type FVAnn = DVarSet -- | Every node in a binding group annotated with its -- (non-global) free variables, both Ids and TyVars, and type.@@ -558,23 +553,11 @@ freeVarsOf :: CoreExprWithFVs -> DIdSet -- ^ Inverse function to 'freeVars'-freeVarsOf (FVAnn { fva_fvs = fvs }, _) = fvs---- | Extract the vars free in an annotated expression's type-freeVarsOfType :: CoreExprWithFVs -> DTyCoVarSet-freeVarsOfType (FVAnn { fva_ty_fvs = ty_fvs }, _) = ty_fvs---- | Extract the type of an annotated expression. (This is cheap.)-exprTypeFV :: CoreExprWithFVs -> Type-exprTypeFV (FVAnn { fva_ty = ty }, _) = ty+freeVarsOf (fvs, _) = fvs -- | Extract the vars reported in a FVAnn freeVarsOfAnn :: FVAnn -> DIdSet-freeVarsOfAnn = fva_fvs---- | Extract the type-level vars reported in a FVAnn-freeVarsOfTypeAnn :: FVAnn -> DTyCoVarSet-freeVarsOfTypeAnn = fva_ty_fvs+freeVarsOfAnn fvs = fvs noFVs :: VarSet noFVs = emptyVarSet@@ -594,10 +577,9 @@ delBinderFV :: Var -> DVarSet -> DVarSet -- This way round, so we can do it multiple times using foldr --- (b `delBinderFV` s) removes the binder b from the free variable set s,--- but *adds* to s------ the free variables of b's type+-- (b `delBinderFV` s)+-- * removes the binder b from the free variable set s,+-- * AND *adds* to s the free variables of b's type -- -- This is really important for some lambdas: -- In (\x::a -> x) the only mention of "a" is in the binder.@@ -726,48 +708,33 @@ where go :: CoreExpr -> CoreExprWithFVs go (Var v)- = (FVAnn fvs ty_fvs (idType v), AnnVar v)+ | isLocalVar v = (aFreeVar v `unionFVs` ty_fvs, AnnVar v)+ | otherwise = (emptyDVarSet, AnnVar v) where- -- ToDo: insert motivating example for why we *need*- -- to include the idSpecVars in the FV list.- -- Actually [June 98] I don't think it's necessary- -- fvs = fvs_v `unionVarSet` idSpecVars v-- (fvs, ty_fvs)- | isLocalVar v = (aFreeVar v `unionFVs` ty_fvs, dVarTypeTyCoVars v)- | otherwise = (emptyDVarSet, emptyDVarSet)+ ty_fvs = dVarTypeTyCoVars v -- Do we need this? - go (Lit lit) = (FVAnn emptyDVarSet emptyDVarSet (literalType lit), AnnLit lit)+ go (Lit lit) = (emptyDVarSet, AnnLit lit) go (Lam b body)- = ( FVAnn { fva_fvs = b_fvs `unionFVs` (b `delBinderFV` body_fvs)- , fva_ty_fvs = b_fvs `unionFVs` (b `delBinderFV` body_ty_fvs)- , fva_ty = mkFunTy b_ty body_ty }+ = ( b_fvs `unionFVs` (b `delBinderFV` body_fvs) , AnnLam b body' ) where- body'@(FVAnn { fva_fvs = body_fvs, fva_ty_fvs = body_ty_fvs- , fva_ty = body_ty }, _) = go body+ body'@(body_fvs, _) = go body b_ty = idType b b_fvs = tyCoVarsOfTypeDSet b_ty go (App fun arg)- = ( FVAnn { fva_fvs = freeVarsOf fun' `unionFVs` freeVarsOf arg'- , fva_ty_fvs = tyCoVarsOfTypeDSet res_ty- , fva_ty = res_ty }+ = ( freeVarsOf fun' `unionFVs` freeVarsOf arg' , AnnApp fun' arg' ) where fun' = go fun- fun_ty = exprTypeFV fun' arg' = go arg- res_ty = applyTypeToArg fun_ty arg go (Case scrut bndr ty alts)- = ( FVAnn { fva_fvs = (bndr `delBinderFV` alts_fvs)- `unionFVs` freeVarsOf scrut2- `unionFVs` tyCoVarsOfTypeDSet ty- -- don't need to look at (idType bndr)- -- b/c that's redundant with scrut- , fva_ty_fvs = tyCoVarsOfTypeDSet ty- , fva_ty = ty }+ = ( (bndr `delBinderFV` alts_fvs)+ `unionFVs` freeVarsOf scrut2+ `unionFVs` tyCoVarsOfTypeDSet ty+ -- don't need to look at (idType bndr)+ -- b/c that's redundant with scrut , AnnCase scrut2 bndr ty alts2 ) where scrut2 = go scrut@@ -781,45 +748,25 @@ rhs2 = go rhs go (Let bind body)- = ( FVAnn { fva_fvs = bind_fvs- , fva_ty_fvs = freeVarsOfType body2- , fva_ty = exprTypeFV body2 }- , AnnLet bind2 body2 )+ = (bind_fvs, AnnLet bind2 body2) where (bind2, bind_fvs) = freeVarsBind bind (freeVarsOf body2) body2 = go body go (Cast expr co)- = ( FVAnn (freeVarsOf expr2 `unionFVs` cfvs) (tyCoVarsOfTypeDSet to_ty) to_ty- , AnnCast expr2 (c_ann, co) )+ = ( freeVarsOf expr2 `unionFVs` cfvs+ , AnnCast expr2 (cfvs, co) ) where expr2 = go expr cfvs = tyCoVarsOfCoDSet co- c_ann = FVAnn cfvs (tyCoVarsOfTypeDSet co_ki) co_ki- co_ki = coercionType co- Just (_, to_ty) = splitCoercionType_maybe co_ki - go (Tick tickish expr)- = ( FVAnn { fva_fvs = tickishFVs tickish `unionFVs` freeVarsOf expr2- , fva_ty_fvs = freeVarsOfType expr2- , fva_ty = exprTypeFV expr2 }+ = ( tickishFVs tickish `unionFVs` freeVarsOf expr2 , AnnTick tickish expr2 ) where expr2 = go expr tickishFVs (Breakpoint _ ids) = mkDVarSet ids tickishFVs _ = emptyDVarSet - go (Type ty) = ( FVAnn (tyCoVarsOfTypeDSet ty)- (tyCoVarsOfTypeDSet ki)- ki- , AnnType ty)- where- ki = typeKind ty-- go (Coercion co) = ( FVAnn (tyCoVarsOfCoDSet co)- (tyCoVarsOfTypeDSet ki)- ki- , AnnCoercion co)- where- ki = coercionType co+ go (Type ty) = (tyCoVarsOfTypeDSet ty, AnnType ty)+ go (Coercion co) = (tyCoVarsOfCoDSet co, AnnCoercion co)
coreSyn/CoreLint.hs view
@@ -21,6 +21,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreFVs import CoreUtils@@ -64,10 +66,10 @@ import HscTypes import DynFlags import Control.Monad-#if __GLASGOW_HASKELL__ > 710 import qualified Control.Monad.Fail as MonadFail-#endif import MonadUtils+import Data.Foldable ( toList )+import Data.List.NonEmpty ( NonEmpty ) import Data.Maybe import Pair import qualified GHC.LanguageExtensions as LangExt@@ -266,6 +268,7 @@ coreDumpFlag CoreLiberateCase = Just Opt_D_verbose_core2core coreDumpFlag CoreDoStaticArgs = Just Opt_D_verbose_core2core coreDumpFlag CoreDoCallArity = Just Opt_D_dump_call_arity+coreDumpFlag CoreDoExitify = Just Opt_D_dump_exitify coreDumpFlag CoreDoStrictness = Just Opt_D_dump_stranal coreDumpFlag CoreDoWorkerWrapper = Just Opt_D_dump_worker_wrapper coreDumpFlag CoreDoSpecialising = Just Opt_D_dump_spec@@ -318,9 +321,11 @@ | not (isEmptyBag warns) , not (hasNoDebugOutput dflags) , showLintWarnings pass- = putLogMsg dflags NoReason Err.SevDump noSrcSpan+ -- If the Core linter encounters an error, output to stderr instead of+ -- stdout (#13342)+ = putLogMsg dflags NoReason Err.SevInfo noSrcSpan (defaultDumpStyle dflags)- (lint_banner "warnings" (ppr pass) $$ Err.pprMessageBag warns)+ (lint_banner "warnings" (ppr pass) $$ Err.pprMessageBag (mapBag ($$ blankLine) warns)) | otherwise = return () where@@ -453,8 +458,16 @@ * * ************************************************************************ -We use this to check all unfoldings that come in from interfaces-(it is very painful to catch errors otherwise):+Note [Linting Unfoldings from Interfaces]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++We use this to check all top-level unfoldings that come in from interfaces+(it is very painful to catch errors otherwise).++We do not need to call lintUnfolding on unfoldings that are nested within+top-level unfoldings; they are linted when we lint the top-level unfolding;+hence the `TopLevelFlag` on `tcPragExpr` in TcIface.+ -} lintUnfolding :: DynFlags@@ -546,6 +559,7 @@ (mkInvalidJoinPointMsg binder binder_ty) ; when (lf_check_inline_loop_breakers flags+ && isStableUnfolding (realIdUnfolding binder) && isStrongLoopBreaker (idOccInfo binder) && isInlinePragma (idInlinePragma binder)) (addWarnL (text "INLINE binder is (non-rule) loop breaker:" <+> ppr binder))@@ -564,7 +578,7 @@ -- Check that the binder's arity is within the bounds imposed by -- the type and the strictness signature. See Note [exprArity invariant] -- and Note [Trimming arity]- ; checkL (idArity binder <= length (typeArity (idType binder)))+ ; checkL (typeArity (idType binder) `lengthAtLeast` idArity binder) (text "idArity" <+> ppr (idArity binder) <+> text "exceeds typeArity" <+> ppr (length (typeArity (idType binder))) <> colon <+>@@ -572,7 +586,7 @@ ; case splitStrictSig (idStrictness binder) of (demands, result_info) | isBotRes result_info ->- checkL (idArity binder <= length demands)+ checkL (demands `lengthAtLeast` idArity binder) (text "idArity" <+> ppr (idArity binder) <+> text "exceeds arity imposed by the strictness signature" <+> ppr (idStrictness binder) <> colon <+>@@ -580,8 +594,10 @@ _ -> return () ; mapM_ (lintCoreRule binder binder_ty) (idCoreRules binder)- ; lintIdUnfolding binder binder_ty (idUnfolding binder) } + ; addLoc (UnfoldingOf binder) $+ lintIdUnfolding binder binder_ty (idUnfolding binder) }+ -- We should check the unfolding, if any, but this is tricky because -- the unfolding is a SimplifiableCoreExpr. Give up for now. @@ -609,7 +625,7 @@ ; return $ mkLamType var' body_ty } lint_join_lams n tot True _other- = failWithL $ mkBadJoinArityMsg bndr tot (tot-n)+ = failWithL $ mkBadJoinArityMsg bndr tot (tot-n) rhs lint_join_lams _ _ False rhs = markAllJoinsBad $ lintCoreExpr rhs -- Future join point, not yet eta-expanded@@ -783,13 +799,9 @@ ; (alt_ty, _) <- lintInTy alt_ty ; (var_ty, _) <- lintInTy (idType var) - -- See Note [No alternatives lint check]- ; when (null alts) $- do { checkL (not (exprIsHNF scrut))- (text "No alternatives for a case scrutinee in head-normal form:" <+> ppr scrut)- ; checkWarnL scrut_diverges- (text "No alternatives for a case scrutinee not known to diverge for sure:" <+> ppr scrut)- }+ -- We used to try to check whether a case expression with no+ -- alternatives was legitimate, but this didn't work.+ -- See Note [No alternatives lint check] for details. -- See Note [Rules for floating-point comparisons] in PrelRules ; let isLitPat (LitAlt _, _ , _) = True@@ -916,24 +928,47 @@ {- Note [No alternatives lint check] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Case expressions with no alternatives are odd beasts, and worth looking at-in the linter (cf Trac #10180). We check two things:+Case expressions with no alternatives are odd beasts, and it would seem+like they would worth be looking at in the linter (cf Trac #10180). We+used to check two things: -* exprIsHNF is false: certainly, it would be terribly wrong if the- scrutinee was already in head normal form.+* exprIsHNF is false: it would *seem* to be terribly wrong if+ the scrutinee was already in head normal form. * exprIsBottom is true: we should be able to see why GHC believes the scrutinee is diverging for sure. -In principle, the first check is redundant: exprIsBottom == True will-always imply exprIsHNF == False. But the first check is reliable: If-exprIsHNF == True, then there definitely is a problem (exprIsHNF errs-on the right side). If the second check triggers then it may be the-case that the compiler got smarter elsewhere, and the empty case is-correct, but that exprIsBottom is unable to see it. In particular, the-empty-type check in exprIsBottom is an approximation. Therefore, this-check is not fully reliable, and we keep both around.+It was already known that the second test was not entirely reliable.+Unfortunately (Trac #13990), the first test turned out not to be reliable+either. Getting the checks right turns out to be somewhat complicated. +For example, suppose we have (comment 8)++ data T a where+ TInt :: T Int++ absurdTBool :: T Bool -> a+ absurdTBool v = case v of++ data Foo = Foo !(T Bool)++ absurdFoo :: Foo -> a+ absurdFoo (Foo x) = absurdTBool x++GHC initially accepts the empty case because of the GADT conditions. But then+we inline absurdTBool, getting++ absurdFoo (Foo x) = case x of++x is in normal form (because the Foo constructor is strict) but the+case is empty. To avoid this problem, GHC would have to recognize+that matching on Foo x is already absurd, which is not so easy.++More generally, we don't really know all the ways that GHC can+lose track of why an expression is bottom, so we shouldn't make too+much fuss when that happens.++ Note [Beta redexes] ~~~~~~~~~~~~~~~~~~~ Consider:@@ -1088,7 +1123,7 @@ where (con_alts, maybe_deflt) = findDefault alts - -- Check that successive alternatives have increasing tags+ -- Check that successive alternatives have strictly increasing tags increasing_tag (alt1 : rest@( alt2 : _)) = alt1 `ltAlt` alt2 && increasing_tag rest increasing_tag _ = True @@ -1284,12 +1319,12 @@ -- should be represented with the FunTy constructor. See Note [Linting -- function types] and Note [Representation of function types]. | isFunTyCon tc- , length tys == 4+ , tys `lengthIs` 4 = failWithL (hang (text "Saturated application of (->)") 2 (ppr ty)) | isTypeSynonymTyCon tc || isTypeFamilyTyCon tc -- Also type synonyms and type families- , length tys < tyConArity tc+ , tys `lengthLessThan` tyConArity tc = failWithL (hang (text "Un-saturated type application") 2 (ppr ty)) | otherwise@@ -1346,8 +1381,8 @@ -- See Note [GHC Formalism] lintArrow what k1 k2 -- Eg lintArrow "type or kind `blah'" k1 k2 -- or lintarrow "coercion `blah'" k1 k2- = do { unless (okArrowArgKind k1) (addErrL (msg (text "argument") k1))- ; unless (okArrowResultKind k2) (addErrL (msg (text "result") k2))+ = do { unless (classifiesTypeWithValues k1) (addErrL (msg (text "argument") k1))+ ; unless (classifiesTypeWithValues k2) (addErrL (msg (text "result") k2)) ; return liftedTypeKind } where msg ar k@@ -1386,23 +1421,28 @@ -- Note [The substitution invariant] in TyCoRep ; foldlM (go_app in_scope) kfn kas } where- fail_msg = vcat [ hang (text "Kind application error in") 2 doc- , nest 2 (text "Function kind =" <+> ppr kfn)- , nest 2 (text "Arg kinds =" <+> ppr kas) ]+ fail_msg extra = vcat [ hang (text "Kind application error in") 2 doc+ , nest 2 (text "Function kind =" <+> ppr kfn)+ , nest 2 (text "Arg kinds =" <+> ppr kas)+ , extra ] - go_app in_scope kfn ka+ go_app in_scope kfn tka | Just kfn' <- coreView kfn- = go_app in_scope kfn' ka+ = go_app in_scope kfn' tka - go_app _ (FunTy kfa kfb) (_,ka)- = do { unless (ka `eqType` kfa) (addErrL fail_msg)+ go_app _ (FunTy kfa kfb) tka@(_,ka)+ = do { unless (ka `eqType` kfa) $+ addErrL (fail_msg (text "Fun:" <+> (ppr kfa $$ ppr tka))) ; return kfb } - go_app in_scope (ForAllTy (TvBndr kv _vis) kfn) (ta,ka)- = do { unless (ka `eqType` tyVarKind kv) (addErrL fail_msg)+ go_app in_scope (ForAllTy (TvBndr kv _vis) kfn) tka@(ta,ka)+ = do { let kv_kind = tyVarKind kv+ ; unless (ka `eqType` kv_kind) $+ addErrL (fail_msg (text "Forall:" <+> (ppr kv $$ ppr kv_kind $$ ppr tka))) ; return (substTyWithInScope in_scope [kv] [ta] kfn) } - go_app _ _ _ = failWithL fail_msg+ go_app _ kfn ka+ = failWithL (fail_msg (text "Not a fun:" <+> (ppr kfn $$ ppr ka))) {- ********************************************************************* * *@@ -1421,16 +1461,14 @@ ; rhs_ty <- case isJoinId_maybe fun of Just join_arity -> do { checkL (args `lengthIs` join_arity) $- mkBadJoinPointRuleMsg fun join_arity rule+ mkBadJoinPointRuleMsg fun join_arity rule -- See Note [Rules for join points] ; lintCoreExpr rhs } _ -> markAllJoinsBad $ lintCoreExpr rhs ; ensureEqTys lhs_ty rhs_ty $ (rule_doc <+> vcat [ text "lhs type:" <+> ppr lhs_ty , text "rhs type:" <+> ppr rhs_ty ])- ; let bad_bndrs = filterOut (`elemVarSet` exprsFreeVars args) $- filter (`elemVarSet` exprFreeVars rhs) $- bndrs+ ; let bad_bndrs = filter is_bad_bndr bndrs ; checkL (null bad_bndrs) (rule_doc <+> text "unbound" <+> ppr bad_bndrs)@@ -1439,6 +1477,16 @@ where rule_doc = text "Rule" <+> doubleQuotes (ftext name) <> colon + lhs_fvs = exprsFreeVars args+ rhs_fvs = exprFreeVars rhs++ is_bad_bndr :: Var -> Bool+ -- See Note [Unbound RULE binders] in Rules+ is_bad_bndr bndr = not (bndr `elemVarSet` lhs_fvs)+ && bndr `elemVarSet` rhs_fvs+ && isNothing (isReflCoVar_maybe bndr)++ {- Note [Linting rules] ~~~~~~~~~~~~~~~~~~~~~~~ It's very bad if simplifying a rule means that one of the template@@ -1458,7 +1506,7 @@ NB (Trac #11643): it's possible that a variable listed in the binders becomes not-mentioned on both LHS and RHS. Here's a silly example:- RULE forall x y. f (g x y) = g (x+1 (y-1)+ RULE forall x y. f (g x y) = g (x+1) (y-1) And suppose worker/wrapper decides that 'x' is Absent. Then we'll end up with RULE forall x y. f ($gw y) = $gw (x+1)@@ -1618,15 +1666,13 @@ ; check_kinds kco k1 k2 } PluginProv _ -> return () -- no extra checks- HoleProv h -> addErrL $- text "Unfilled coercion hole:" <+> ppr h ; when (r /= Phantom && classifiesTypeWithValues k1 && classifiesTypeWithValues k2) (checkTypes ty1 ty2) ; return (k1, k2, ty1, ty2, r) } where- report s = hang (text $ "Unsafe coercion between " ++ s)+ report s = hang (text $ "Unsafe coercion: " ++ s) 2 (vcat [ text "From:" <+> ppr ty1 , text " To:" <+> ppr ty2]) isUnBoxed :: PrimRep -> Bool@@ -1634,10 +1680,20 @@ -- see #9122 for discussion of these checks checkTypes t1 t2- = do { checkWarnL (reps1 `equalLength` reps2)- (report "values with different # of reps")- ; zipWithM_ validateCoercion reps1 reps2 }+ = do { checkWarnL (not lev_poly1)+ (report "left-hand type is levity-polymorphic")+ ; checkWarnL (not lev_poly2)+ (report "right-hand type is levity-polymorphic")+ ; when (not (lev_poly1 || lev_poly2)) $+ do { checkWarnL (reps1 `equalLength` reps2)+ (report "between values with different # of reps")+ ; zipWithM_ validateCoercion reps1 reps2 }} where+ lev_poly1 = isTypeLevPoly t1+ lev_poly2 = isTypeLevPoly t2++ -- don't look at these unless lev_poly1/2 are False+ -- Otherwise, we get #13458 reps1 = typePrimRep t1 reps2 = typePrimRep t2 @@ -1645,15 +1701,15 @@ validateCoercion rep1 rep2 = do { dflags <- getDynFlags ; checkWarnL (isUnBoxed rep1 == isUnBoxed rep2)- (report "unboxed and boxed value")- ; checkWarnL (TyCon.primRepSizeW dflags rep1- == TyCon.primRepSizeW dflags rep2)- (report "unboxed values of different size")+ (report "between unboxed and boxed value")+ ; checkWarnL (TyCon.primRepSizeB dflags rep1+ == TyCon.primRepSizeB dflags rep2)+ (report "between unboxed values of different size") ; let fl = liftM2 (==) (TyCon.primRepIsFloat rep1) (TyCon.primRepIsFloat rep2) ; case fl of- Nothing -> addWarnL (report "vector types")- Just False -> addWarnL (report "float and integral values")+ Nothing -> addWarnL (report "between vector types")+ Just False -> addWarnL (report "between float and integral values") _ -> return () } @@ -1693,7 +1749,7 @@ , isInjectiveTyCon tc_s r -- see Note [NthCo and newtypes] in TyCoRep , tys_s `equalLength` tys_t- , n < length tys_s+ , tys_s `lengthExceeds` n -> return (ks, kt, ts, tt, tr) where ts = getNth tys_s n@@ -1744,7 +1800,7 @@ , cab_roles = roles , cab_lhs = lhs , cab_rhs = rhs } = coAxiomNthBranch con ind- ; unless (length ktvs + length cvs == length cos) $+ ; unless (cos `equalLength` (ktvs ++ cvs)) $ bad_ax (text "lengths") ; subst <- getTCvSubst ; let empty_subst = zapTCvSubst subst@@ -1816,6 +1872,11 @@ [ text "Expected:" <+> int (n + length es) , text "Provided:" <+> int n ] +lintCoercion (HoleCo h)+ = do { addErrL $ text "Unfilled coercion hole:" <+> ppr h+ ; lintCoercion (CoVarCo (coHoleCoVar h)) }++ ---------- lintUnliftedCoVar :: CoVar -> LintM () lintUnliftedCoVar cv@@ -1920,17 +1981,15 @@ (<*>) = ap instance Monad LintM where- fail err = failWithL (text err)+ fail = MonadFail.fail m >>= k = LintM (\ env errs -> let (res, errs') = unLintM m env errs in case res of Just r -> unLintM (k r) env errs' Nothing -> (Nothing, errs')) -#if __GLASGOW_HASKELL__ > 710 instance MonadFail.MonadFail LintM where fail err = failWithL (text err)-#endif instance HasDynFlags LintM where getDynFlags = LintM (\ e errs -> (Just (le_dynflags e), errs))@@ -1938,6 +1997,7 @@ data LintLocInfo = RhsOf Id -- The variable bound | LambdaBodyOf Id -- The lambda-binder+ | UnfoldingOf Id -- Unfolding of a binder | BodyOfLetRec [Id] -- One of the binders | CaseAlt CoreAlt -- Case alternative | CasePat CoreAlt -- The *pattern* of the case alternative@@ -1994,10 +2054,9 @@ locs = le_loc env (loc, cxt1) = dumpLoc (head locs) cxts = [snd (dumpLoc loc) | loc <- locs]- context = sdocWithPprDebug $ \dbg -> if dbg- then vcat (reverse cxts) $$ cxt1 $$- text "Substitution:" <+> ppr (le_subst env)- else cxt1+ context = ifPprDebug (vcat (reverse cxts) $$ cxt1 $$+ text "Substitution:" <+> ppr (le_subst env))+ cxt1 mk_msg msg = mkLocMessage SevWarning (mkSrcSpan loc loc) (context $$ msg) @@ -2125,6 +2184,9 @@ dumpLoc (LambdaBodyOf b) = (getSrcLoc b, brackets (text "in body of lambda with binder" <+> pp_binder b)) +dumpLoc (UnfoldingOf b)+ = (getSrcLoc b, brackets (text "in the unfolding of" <+> pp_binder b))+ dumpLoc (BodyOfLetRec []) = (noSrcLoc, brackets (text "In body of a letrec with no binders")) @@ -2180,7 +2242,7 @@ mkNonDefltMsg, mkNonIncreasingAltsMsg :: CoreExpr -> MsgDoc mkNonDefltMsg e- = hang (text "Case expression with DEFAULT not at the beginnning") 4 (ppr e)+ = hang (text "Case expression with DEFAULT not at the beginning") 4 (ppr e) mkNonIncreasingAltsMsg e = hang (text "Case expression with badly-ordered alternatives") 4 (ppr e) @@ -2351,12 +2413,14 @@ = hang (text "Join point has invalid type:") 2 (ppr var <+> dcolon <+> ppr ty) -mkBadJoinArityMsg :: Var -> Int -> Int -> SDoc-mkBadJoinArityMsg var ar nlams+mkBadJoinArityMsg :: Var -> Int -> Int -> CoreExpr -> SDoc+mkBadJoinArityMsg var ar nlams rhs = vcat [ text "Join point has too few lambdas", text "Join var:" <+> ppr var, text "Join arity:" <+> ppr ar,- text "Number of lambdas:" <+> ppr nlams ]+ text "Number of lambdas:" <+> ppr nlams,+ text "Rhs = " <+> ppr rhs+ ] invalidJoinOcc :: Var -> SDoc invalidJoinOcc var@@ -2403,15 +2467,15 @@ pprLeftOrRight CLeft = text "left" pprLeftOrRight CRight = text "right" -dupVars :: [[Var]] -> MsgDoc+dupVars :: [NonEmpty Var] -> MsgDoc dupVars vars = hang (text "Duplicate variables brought into scope")- 2 (ppr vars)+ 2 (ppr (map toList vars)) -dupExtVars :: [[Name]] -> MsgDoc+dupExtVars :: [NonEmpty Name] -> MsgDoc dupExtVars vars = hang (text "Duplicate top-level variables with the same qualified name")- 2 (ppr vars)+ 2 (ppr (map toList vars)) {- ************************************************************************
coreSyn/CoreOpt.hs view
@@ -20,8 +20,10 @@ #include "HsVersions.h" -import CoreArity( joinRhsArity, etaExpandToJoinPoint )+import GhcPrelude +import CoreArity( etaExpandToJoinPoint )+ import CoreSyn import CoreSubst import CoreUtils@@ -143,7 +145,7 @@ rules' = substRulesForImportedIds final_subst rules vects' = substVects final_subst vects -- We never unconditionally inline into rules,- -- hence pasing just a substitution+ -- hence paying just a substitution do_one (env, binds') bind = case simple_opt_bind env bind of@@ -479,7 +481,7 @@ id1 = uniqAway in_scope old_id id2 = setIdType id1 (substTy subst (idType old_id)) new_id = zapFragileIdInfo id2- -- Zaps rules, worker-info, unfolding, and fragile OccInfo+ -- Zaps rules, unfolding, and fragile OccInfo -- The unfolding and rules will get added back later, by add_info new_in_scope = in_scope `extendInScopeSet` new_id@@ -642,58 +644,18 @@ = Just (bndr, rhs) | AlwaysTailCalled join_arity <- tailCallInfo (idOccInfo bndr)- , not (bad_unfolding join_arity (idUnfolding bndr)) , (bndrs, body) <- etaExpandToJoinPoint join_arity rhs = Just (bndr `asJoinId` join_arity, mkLams bndrs body) | otherwise = Nothing - where- -- bad_unfolding returns True if we should /not/ convert a non-join-id- -- into a join-id, even though it is AlwaysTailCalled- -- See Note [Join points and INLINE pragmas]- bad_unfolding join_arity (CoreUnfolding { uf_src = src, uf_tmpl = rhs })- = isStableSource src && join_arity > joinRhsArity rhs- bad_unfolding _ (DFunUnfolding {})- = True- bad_unfolding _ _- = False- joinPointBindings_maybe :: [(InBndr, InExpr)] -> Maybe [(InBndr, InExpr)] joinPointBindings_maybe bndrs = mapM (uncurry joinPointBinding_maybe) bndrs -{- Note [Join points and INLINE pragmas]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider- f x = let g = \x. not -- Arity 1- {-# INLINE g #-}- in case x of- A -> g True True- B -> g True False- C -> blah2--Here 'g' is always tail-called applied to 2 args, but the stable-unfolding captured by the INLINE pragma has arity 1. If we try to-convert g to be a join point, its unfolding will still have arity 1-(since it is stable, and we don't meddle with stable unfoldings), and-Lint will complain (see Note [Invariants on join points], (2a), in-CoreSyn. Trac #13413.--Moreover, since g is going to be inlined anyway, there is no benefit-from making it a join point.--If it is recursive, and uselessly marked INLINE, this will stop us-making it a join point, which is a annoying. But occasionally-(notably in class methods; see Note [Instances and loop breakers] in-TcInstDcls) we mark recurive things as INLINE but the recursion-unravels; so ignoring INLINE pragmas on recursive things isn't good-either.---************************************************************************+{- ********************************************************************* * * exprIsConApp_maybe * *@@ -755,7 +717,7 @@ -- | Returns @Just (dc, [t1..tk], [x1..xn])@ if the argument expression is -- a *saturated* constructor application of the form @dc t1..tk x1 .. xn@,--- where t1..tk are the *universally-qantified* type args of 'dc'+-- where t1..tk are the *universally-quantified* type args of 'dc' exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (DataCon, [Type], [CoreExpr]) exprIsConApp_maybe (in_scope, id_unf) expr = go (Left in_scope) expr (CC [] (mkRepReflCo (exprType expr)))@@ -961,7 +923,7 @@ (K e1 .. en) |> co and we want to tranform to (K e1' .. en')- by pushing the coercion into the oarguments+ by pushing the coercion into the arguments -} pushCoArgs :: Coercion -> [CoreArg] -> Maybe ([CoreArg], Coercion)@@ -1081,7 +1043,7 @@ -- (C x y) `cast` (g :: T a ~ S [a]), -- where S is a type function. In fact, exprIsConApp -- will probably not be called in such circumstances,- -- but there't nothing wrong with it+ -- but there's nothing wrong with it = let tc_arity = tyConArity to_tc
coreSyn/CorePrep.hs view
@@ -14,6 +14,8 @@ #include "HsVersions.h" +import GhcPrelude+ import OccurAnal import HscTypes@@ -58,12 +60,14 @@ import SrcLoc ( SrcSpan(..), realSrcLocSpan, mkRealSrcLoc ) import Data.Bits import MonadUtils ( mapAccumLM )-import Data.List ( mapAccumL )+import Data.List ( mapAccumL, foldl' ) import Control.Monad+import CostCentre ( CostCentre, ccFromThisModule )+import qualified Data.Set as S {- -- ------------------------------------------------------------------------------ Overview+-- Note [CorePrep Overview] -- --------------------------------------------------------------------------- The goal of this pass is to prepare for code generation.@@ -122,6 +126,10 @@ (non-type) applications where we can, and make sure that we annotate according to scoping rules when floating. +12. Collect cost centres (including cost centres in unfoldings) if we're in+ profiling mode. We have to do this here beucase we won't have unfoldings+ after this pass (see `zapUnfolding` and Note [Drop unfoldings and rules].+ This is all done modulo type applications and abstractions, so that when type erasure is done for conversion to STG, we don't end up with any trivial or useless bindings.@@ -167,7 +175,7 @@ -} corePrepPgm :: HscEnv -> Module -> ModLocation -> CoreProgram -> [TyCon]- -> IO CoreProgram+ -> IO (CoreProgram, S.Set CostCentre) corePrepPgm hsc_env this_mod mod_loc binds data_tycons = withTiming (pure dflags) (text "CorePrep"<+>brackets (ppr this_mod))@@ -175,7 +183,13 @@ us <- mkSplitUniqSupply 's' initialCorePrepEnv <- mkInitialCorePrepEnv dflags hsc_env - let implicit_binds = mkDataConWorkers dflags mod_loc data_tycons+ let cost_centres+ | WayProf `elem` ways dflags+ = collectCostCentres this_mod binds+ | otherwise+ = S.empty++ implicit_binds = mkDataConWorkers dflags mod_loc data_tycons -- NB: we must feed mkImplicitBinds through corePrep too -- so that they are suitably cloned and eta-expanded @@ -185,7 +199,7 @@ return (deFloatTop (floats1 `appendFloats` floats2)) endPassIO hsc_env alwaysQualify CorePrep binds_out []- return binds_out+ return (binds_out, cost_centres) where dflags = hsc_dflags hsc_env @@ -645,8 +659,21 @@ ; let bndr1 = bndr `setIdUnfolding` evaldUnfolding -- Record that the case binder is evaluated in the alternatives ; (env', bndr2) <- cpCloneBndr env bndr1- ; alts' <- mapM (sat_alt env') alts- ; return (floats, Case scrut' bndr2 ty alts') }+ ; let alts'+ -- This flag is intended to aid in debugging strictness+ -- analysis bugs. These are particularly nasty to chase down as+ -- they may manifest as segmentation faults. When this flag is+ -- enabled we instead produce an 'error' expression to catch+ -- the case where a function we think should bottom+ -- unexpectedly returns.+ | gopt Opt_CatchBottoms (cpe_dynFlags env)+ , not (altsAreExhaustive alts)+ = addDefault alts (Just err)+ | otherwise = alts+ where err = mkRuntimeErrorApp rUNTIME_ERROR_ID ty+ "Bottoming expression returned"+ ; alts'' <- mapM (sat_alt env') alts'+ ; return (floats, Case scrut' bndr2 ty alts'') } where sat_alt env (con, bs, rhs) = do { (env2, bs') <- cpCloneBndrs env bs@@ -1585,3 +1612,39 @@ (ppr other) wrapBind t (NonRec binder rhs) = NonRec binder (mkTick t rhs) wrapBind t (Rec pairs) = Rec (mapSnd (mkTick t) pairs)++------------------------------------------------------------------------------+-- Collecting cost centres+-- ---------------------------------------------------------------------------++-- | Collect cost centres defined in the current module, including those in+-- unfoldings.+collectCostCentres :: Module -> CoreProgram -> S.Set CostCentre+collectCostCentres mod_name+ = foldl' go_bind S.empty+ where+ go cs e = case e of+ Var{} -> cs+ Lit{} -> cs+ App e1 e2 -> go (go cs e1) e2+ Lam _ e -> go cs e+ Let b e -> go (go_bind cs b) e+ Case scrt _ _ alts -> go_alts (go cs scrt) alts+ Cast e _ -> go cs e+ Tick (ProfNote cc _ _) e ->+ go (if ccFromThisModule cc mod_name then S.insert cc cs else cs) e+ Tick _ e -> go cs e+ Type{} -> cs+ Coercion{} -> cs++ go_alts = foldl' (\cs (_con, _bndrs, e) -> go cs e)++ go_bind :: S.Set CostCentre -> CoreBind -> S.Set CostCentre+ go_bind cs (NonRec b e) =+ go (maybe cs (go cs) (get_unf b)) e+ go_bind cs (Rec bs) =+ foldl' (\cs' (b, e) -> go (maybe cs' (go cs') (get_unf b)) e) cs bs++ -- Unfoldings may have cost centres that in the original definion are+ -- optimized away, see #5889.+ get_unf = maybeUnfoldingTemplate . realIdUnfolding
coreSyn/CoreSeq.hs view
@@ -10,6 +10,8 @@ megaSeqIdInfo, seqRuleInfo, seqBinds, ) where +import GhcPrelude+ import CoreSyn import IdInfo import Demand( seqDemand, seqStrictSig )
coreSyn/CoreStats.hs view
@@ -11,22 +11,25 @@ CoreStats(..), coreBindsStats, exprStats, ) where +import GhcPrelude+ import BasicTypes import CoreSyn import Outputable import Coercion import Var-import Type (Type, typeSize, seqType)-import Id (idType, isJoinId)-import CoreSeq (megaSeqIdInfo)+import Type (Type, typeSize)+import Id (isJoinId) -data CoreStats = CS { cs_tm :: Int -- Terms- , cs_ty :: Int -- Types- , cs_co :: Int -- Coercions- , cs_vb :: Int -- Local value bindings- , cs_jb :: Int } -- Local join bindings+import Data.List (foldl') +data CoreStats = CS { cs_tm :: !Int -- Terms+ , cs_ty :: !Int -- Types+ , cs_co :: !Int -- Coercions+ , cs_vb :: !Int -- Local value bindings+ , cs_jb :: !Int } -- Local join bindings + instance Outputable CoreStats where ppr (CS { cs_tm = i1, cs_ty = i2, cs_co = i3, cs_vb = i4, cs_jb = i5 }) = braces (sep [text "terms:" <+> intWithCommas i1 <> comma,@@ -46,7 +49,7 @@ oneTM = zeroCS { cs_tm = 1 } sumCS :: (a -> CoreStats) -> [a] -> CoreStats-sumCS f = foldr (plusCS . f) zeroCS+sumCS f = foldl' (\s a -> plusCS s (f a)) zeroCS coreBindsStats :: [CoreBind] -> CoreStats coreBindsStats = sumCS (bindStats TopLevel)@@ -99,43 +102,38 @@ -- We use coreBindStats for user printout -- but this one is a quick and dirty basis for -- the simplifier's tick limit-coreBindsSize bs = foldr ((+) . bindSize) 0 bs+coreBindsSize bs = sum (map bindSize bs) exprSize :: CoreExpr -> Int -- ^ A measure of the size of the expressions, strictly greater than 0--- It also forces the expression pretty drastically as a side effect -- Counts *leaves*, not internal nodes. Types and coercions are not counted.-exprSize (Var v) = v `seq` 1-exprSize (Lit lit) = lit `seq` 1+exprSize (Var _) = 1+exprSize (Lit _) = 1 exprSize (App f a) = exprSize f + exprSize a exprSize (Lam b e) = bndrSize b + exprSize e exprSize (Let b e) = bindSize b + exprSize e-exprSize (Case e b t as) = seqType t `seq`- exprSize e + bndrSize b + 1 + foldr ((+) . altSize) 0 as-exprSize (Cast e co) = (seqCo co `seq` 1) + exprSize e+exprSize (Case e b _ as) = exprSize e + bndrSize b + 1 + sum (map altSize as)+exprSize (Cast e _) = 1 + exprSize e exprSize (Tick n e) = tickSize n + exprSize e-exprSize (Type t) = seqType t `seq` 1-exprSize (Coercion co) = seqCo co `seq` 1+exprSize (Type _) = 1+exprSize (Coercion _) = 1 tickSize :: Tickish Id -> Int-tickSize (ProfNote cc _ _) = cc `seq` 1-tickSize _ = 1 -- the rest are strict+tickSize (ProfNote _ _ _) = 1+tickSize _ = 1 bndrSize :: Var -> Int-bndrSize b | isTyVar b = seqType (tyVarKind b) `seq` 1- | otherwise = seqType (idType b) `seq`- megaSeqIdInfo (idInfo b) `seq`- 1+bndrSize _ = 1 bndrsSize :: [Var] -> Int bndrsSize = sum . map bndrSize bindSize :: CoreBind -> Int bindSize (NonRec b e) = bndrSize b + exprSize e-bindSize (Rec prs) = foldr ((+) . pairSize) 0 prs+bindSize (Rec prs) = sum (map pairSize prs) pairSize :: (Var, CoreExpr) -> Int pairSize (b,e) = bndrSize b + exprSize e altSize :: CoreAlt -> Int-altSize (c,bs,e) = c `seq` bndrsSize bs + exprSize e+altSize (_,bs,e) = bndrsSize bs + exprSize e
coreSyn/CoreSubst.hs view
@@ -36,6 +36,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreFVs import CoreSeq@@ -723,7 +725,7 @@ they are knot-tied by substRecBndrs. One case in point was Trac #10627 in which a rule for a function 'f'-referred to 'f' (at a differnet type) on the RHS. But instead of just+referred to 'f' (at a different type) on the RHS. But instead of just substituting in the rhs of the rule, we were calling simpleOptExpr, which looked at the idInfo for 'f'; result <<loop>>.
coreSyn/CoreSyn.hs view
@@ -21,7 +21,7 @@ OutBndr, OutVar, OutCoercion, OutTyVar, OutCoVar, -- ** 'Expr' construction- mkLet, mkLets, mkLams,+ mkLet, mkLets, mkLetNonRec, mkLetRec, mkLams, mkApps, mkTyApps, mkCoApps, mkVarApps, mkTyArg, mkIntLit, mkIntLitInt,@@ -77,7 +77,7 @@ collectAnnArgs, collectAnnArgsTicks, -- ** Operations on annotations- deAnnotate, deAnnotate', deAnnAlt,+ deAnnotate, deAnnotate', deAnnAlt, deAnnBind, collectAnnBndrs, collectNAnnBndrs, -- * Orphanhood@@ -99,6 +99,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CostCentre import VarEnv( InScopeSet ) import Var@@ -308,6 +310,21 @@ | DEFAULT -- ^ Trivial alternative: @case e of { _ -> ... }@ deriving (Eq, Data) +-- This instance is a bit shady. It can only be used to compare AltCons for+-- a single type constructor. Fortunately, it seems quite unlikely that we'll+-- ever need to compare AltCons for different type constructors.+-- The instance adheres to the order described in [CoreSyn case invariants]+instance Ord AltCon where+ compare (DataAlt con1) (DataAlt con2) =+ ASSERT( dataConTyCon con1 == dataConTyCon con2 )+ compare (dataConTag con1) (dataConTag con2)+ compare (DataAlt _) _ = GT+ compare _ (DataAlt _) = LT+ compare (LitAlt l1) (LitAlt l2) = compare l1 l2+ compare (LitAlt _) DEFAULT = GT+ compare DEFAULT DEFAULT = EQ+ compare DEFAULT _ = LT+ -- | Binding, used for top level bindings in a module and local bindings in a @let@. -- If you edit this type, you may need to update the GHC formalism@@ -330,7 +347,7 @@ "wild_". These "wild" variables may appear in the body of the case-expression, and further, may be shadowed within the body. -So the Unique in an Var is not really unique at all. Still, it's very+So the Unique in a Var is not really unique at all. Still, it's very useful to give a constant-time equality/ordering for Vars, and to give a key that can be used to make sets of Vars (VarSet), or mappings from Vars to other things (VarEnv). Moreover, if you do want to eliminate@@ -388,8 +405,6 @@ wrapped in Ticks, as is otherwise done with lifted bindings. CoreToStg expects to see just a plain (Lit (MachStr ...)) expression on the RHS of primitive string bindings; anything else and things break. CoreLint checks this invariant.-To ensure that ticks don't sneak in CoreUtils.mkTick refuses to wrap any-primitve string expression with a tick. Also see Note [Compilation plan for top-level string literals]. @@ -445,7 +460,8 @@ Note [Levity polymorphism invariants] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The levity-polymorphism invariants are these:+The levity-polymorphism invariants are these (as per "Levity Polymorphism",+PLDI '17): * The type of a term-binder must not be levity-polymorphic, unless it is a let(rec)-bound join point@@ -1639,7 +1655,7 @@ so that the occurrence info on the binders is correct. This is important, because the Simplifier does not re-analyse the template when using it. If the occurrence info is wrong- - We may get more simpifier iterations than necessary, because+ - We may get more simplifier iterations than necessary, because once-occ info isn't there - More seriously, we may get an infinite loop if there's a Rec without a loop breaker marked@@ -1670,6 +1686,8 @@ cmpAltCon :: AltCon -> AltCon -> Ordering -- ^ Compares 'AltCon's within a single list of alternatives+-- DEFAULT comes out smallest, so that sorting by AltCon+-- puts alternatives in the order required by #case_invariants# cmpAltCon DEFAULT DEFAULT = EQ cmpAltCon DEFAULT _ = LT @@ -1875,6 +1893,16 @@ mkLet (Rec []) body = body mkLet bind body = Let bind body +-- | @mkLetNonRec bndr rhs body@ wraps @body@ in a @let@ binding @bndr@.+mkLetNonRec :: b -> Expr b -> Expr b -> Expr b+mkLetNonRec b rhs body = Let (NonRec b rhs) body++-- | @mkLetRec binds body@ wraps @body@ in a @let rec@ with the given set of+-- @binds@ if binds is non-empty.+mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b+mkLetRec [] body = body+mkLetRec bs body = Let (Rec bs) body+ -- | Create a binding group where a type variable is bound to a type. Per "CoreSyn#type_let", -- this can only be used to bind something in a non-recursive @let@ expression mkTyBind :: TyVar -> Type -> CoreBind@@ -2133,15 +2161,15 @@ deAnnotate' (AnnLet bind body) = Let (deAnnBind bind) (deAnnotate body)- where- deAnnBind (AnnNonRec var rhs) = NonRec var (deAnnotate rhs)- deAnnBind (AnnRec pairs) = Rec [(v,deAnnotate rhs) | (v,rhs) <- pairs]- deAnnotate' (AnnCase scrut v t alts) = Case (deAnnotate scrut) v t (map deAnnAlt alts) deAnnAlt :: AnnAlt bndr annot -> Alt bndr deAnnAlt (con,args,rhs) = (con,args,deAnnotate rhs)++deAnnBind :: AnnBind b annot -> Bind b+deAnnBind (AnnNonRec var rhs) = NonRec var (deAnnotate rhs)+deAnnBind (AnnRec pairs) = Rec [(v,deAnnotate rhs) | (v,rhs) <- pairs] -- | As 'collectBinders' but for 'AnnExpr' rather than 'Expr' collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
coreSyn/CoreTidy.hs view
@@ -14,8 +14,10 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn-import CoreUnfold ( mkCoreUnfolding )+import CoreSeq ( seqUnfolding ) import CoreArity import Id import IdInfo@@ -221,21 +223,17 @@ (tidy_env', bndrs') = tidyBndrs tidy_env bndrs tidyUnfolding tidy_env- (CoreUnfolding { uf_tmpl = unf_rhs, uf_is_top = top_lvl- , uf_src = src, uf_guidance = guidance })+ unf@(CoreUnfolding { uf_tmpl = unf_rhs, uf_src = src }) unf_from_rhs | isStableSource src- = mkCoreUnfolding src top_lvl (tidyExpr tidy_env unf_rhs) guidance- -- Preserves OccInfo-- -- Note that uf_is_value and friends may be a thunk containing a reference- -- to the old template. Consequently it is important that we rebuild them,- -- despite the fact that they won't change, to avoid a space leak (since,- -- e.g., ToIface doesn't look at them; see #13564). This is the same- -- approach we use in Simplify.simplUnfolding and TcIface.tcUnfolding.+ = seqIt $ unf { uf_tmpl = tidyExpr tidy_env unf_rhs } -- Preserves OccInfo+ -- This seqIt avoids a space leak: otherwise the uf_is_value,+ -- uf_is_conlike, ... fields may retain a reference to the+ -- pre-tidied expression forever (ToIface doesn't look at them) | otherwise = unf_from_rhs+ where seqIt unf = seqUnfolding unf `seq` unf tidyUnfolding _ unf _ = unf -- NoUnfolding or OtherCon {-
coreSyn/CoreUnfold.hs view
@@ -42,6 +42,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags import CoreSyn import PprCore () -- Instances@@ -578,7 +580,7 @@ foldr (addAltSize . size_up_alt) case_size alts where case_size- | is_inline_scrut e, not (lengthExceeds alts 1) = sizeN (-10)+ | is_inline_scrut e, lengthAtMost alts 1 = sizeN (-10) | otherwise = sizeZero -- Normally we don't charge for the case itself, but -- we charge one per alternative (see size_up_alt,@@ -593,7 +595,7 @@ -- case touch# x# of _ -> ... should cost 0 -- (see #4978) --- -- I would like to not have the "not (lengthExceeds alts 1)"+ -- I would like to not have the "lengthAtMost alts 1" -- condition above, but without that some programs got worse -- (spectral/hartel/event and spectral/para). I don't fully -- understand why. (SDM 24/5/11)@@ -649,7 +651,7 @@ -- Don't charge for args, so that wrappers look cheap -- (See comments about wrappers with Case) --- -- IMPORATANT: *do* charge 1 for the alternative, else we+ -- IMPORTANT: *do* charge 1 for the alternative, else we -- find that giant case nests are treated as practically free -- A good example is Foreign.C.Error.errnoToIOError @@ -943,7 +945,7 @@ Code for manipulating sizes -} --- | The size of an candidate expression for unfolding+-- | The size of a candidate expression for unfolding data ExprSize = TooBig | SizeIs { _es_size_is :: {-# UNPACK #-} !Int -- ^ Size found@@ -1472,15 +1474,15 @@ = res_discount -- Over-saturated | otherwise = case cont_info of- BoringCtxt -> 0- CaseCtxt -> res_discount -- Presumably a constructor- ValAppCtxt -> res_discount -- Presumably a function- _ -> 40 `min` res_discount+ BoringCtxt -> 0+ CaseCtxt -> res_discount -- Presumably a constructor+ ValAppCtxt -> res_discount -- Presumably a function+ _ -> 40 `min` res_discount -- ToDo: this 40 `min` res_discount doesn't seem right -- for DiscArgCtxt it shouldn't matter because the function will- -- get the arg discount for any non-triv arg+ -- get the arg discount for any non-triv arg -- for RuleArgCtxt we do want to be keener to inline; but not only- -- constructor results+ -- constructor results -- for RhsCtxt I suppose that exposing a data con is good in general -- And 40 seems very arbitrary --
coreSyn/CoreUtils.hs view
@@ -25,11 +25,12 @@ exprType, coreAltType, coreAltsType, isExprLevPoly, exprIsDupable, exprIsTrivial, getIdFromTrivialExpr, exprIsBottom, getIdFromTrivialExpr_maybe,- exprIsCheap, exprIsExpandable, exprIsOk, CheapAppFun,+ exprIsCheap, exprIsExpandable, exprIsCheapX, CheapAppFun, exprIsHNF, exprOkForSpeculation, exprOkForSideEffects, exprIsWorkFree, exprIsBig, exprIsConLike, rhsIsStatic, isCheapApp, isExpandableApp, exprIsLiteralString, exprIsTopLevelBindable,+ altsAreExhaustive, -- * Equality cheapEqExpr, cheapEqExpr', eqExpr,@@ -57,6 +58,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import PrelNames ( makeStaticName ) import PprCore@@ -83,7 +86,7 @@ import FastString import Maybes import ListSetOps ( minusList )-import BasicTypes ( Arity )+import BasicTypes ( Arity, isConLike ) import Platform import Util import Pair@@ -300,11 +303,6 @@ -> CoreExpr mkTick' top rest expr = case expr of - -- Never tick primitive string literals. These should ultimately float up to- -- the top-level where they must be unadorned. See Note- -- [CoreSyn top-level string literals] for details.- _ | exprIsLiteralString expr -> expr- -- Cost centre ticks should never be reordered relative to each -- other. Therefore we can stop whenever two collide. Tick t2 e@@ -719,7 +717,7 @@ and similarly in cascade for all the join points! NB: it's important that all this is done in [InAlt], *before* we work-on the alternatives themselves, because Simpify.simplAlt may zap the+on the alternatives themselves, because Simplify.simplAlt may zap the occurrence info on the binders in the alternatives, which in turn defeats combineIdenticalAlts (see Trac #7360). @@ -1101,31 +1099,43 @@ (It's quite hard to trigger this bug, but T13155 does so for GHC 8.0.) -Note [Arguments in exprIsOk]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-What predicate should we apply to the argument of an application? We-used to say "exprIsTrivial arg" due to concerns about duplicating-nested constructor applications, but see #4978. The principle here is+Note [Arguments and let-bindings exprIsCheapX]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+What predicate should we apply to the argument of an application, or the+RHS of a let-binding?++We used to say "exprIsTrivial arg" due to concerns about duplicating+nested constructor applications, but see #4978. So now we just recursively+use exprIsCheapX.++We definitely want to treat let and app the same. The principle here is that- let x = a +# b in c *# x+ let x = blah in f x should behave equivalently to- c *# (a +# b)-Since lets with cheap RHSs are accepted, so should paps with cheap arguments+ f blah++This in turn means that the 'letrec g' does not prevent eta expansion+in this (which it previously was):+ f = \x. let v = case x of+ True -> letrec g = \w. blah+ in g+ False -> \x. x+ in \w. v True -} -------------------- exprIsCheap :: CoreExpr -> Bool-exprIsCheap = exprIsOk isCheapApp+exprIsCheap = exprIsCheapX isCheapApp exprIsExpandable :: CoreExpr -> Bool -- See Note [exprIsExpandable]-exprIsExpandable = exprIsOk isExpandableApp+exprIsExpandable = exprIsCheapX isExpandableApp exprIsWorkFree :: CoreExpr -> Bool -- See Note [exprIsWorkFree]-exprIsWorkFree = exprIsOk isWorkFreeApp+exprIsWorkFree = exprIsCheapX isWorkFreeApp ---------------------exprIsOk :: CheapAppFun -> CoreExpr -> Bool-exprIsOk ok_app e+exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool+exprIsCheapX ok_app e = ok e where ok e = go 0 e@@ -1136,19 +1146,19 @@ go _ (Type {}) = True go _ (Coercion {}) = True go n (Cast e _) = go n e- go n (Case scrut _ _ alts) = foldl (&&) (ok scrut)- [ go n rhs | (_,_,rhs) <- alts ]+ go n (Case scrut _ _ alts) = ok scrut &&+ and [ go n rhs | (_,_,rhs) <- alts ] go n (Tick t e) | tickishCounts t = False | otherwise = go n e go n (Lam x e) | isRuntimeVar x = n==0 || go (n-1) e | otherwise = go n e go n (App f e) | isRuntimeArg e = go (n+1) f && ok e | otherwise = go n f- go _ (Let {}) = False+ go n (Let (NonRec _ r) e) = go n e && ok r+ go n (Let (Rec prs) e) = go n e && all (ok . snd) prs -- Case: see Note [Case expressions are work-free]- -- App: see Note [Arguments in exprIsOk]- -- Let: the old exprIsCheap worked through lets+ -- App, Let: see Note [Arguments and let-bindings exprIsCheapX] -------------------------------------@@ -1161,23 +1171,12 @@ -- isCheapApp -- isExpandableApp - -- NB: isCheapApp and isExpandableApp are called from outside- -- this module, so don't be tempted to move the notRedex- -- stuff into the call site in exprIsOk, and remove it- -- from the CheapAppFun implementations---notRedex :: CheapAppFun-notRedex fn n_val_args- = n_val_args == 0 -- No value args- || n_val_args < idArity fn -- Partial application- || isBottomingId fn -- OK to duplicate calls to bottom;- -- it certainly doesn't need to be shared!- isWorkFreeApp :: CheapAppFun isWorkFreeApp fn n_val_args- | notRedex fn n_val_args+ | n_val_args == 0 -- No value args = True+ | n_val_args < idArity fn -- Partial application+ = True | otherwise = case idDetails fn of DataConWorkId {} -> True@@ -1185,11 +1184,11 @@ isCheapApp :: CheapAppFun isCheapApp fn n_val_args- | notRedex fn n_val_args- = True+ | isWorkFreeApp fn n_val_args = True+ | isBottomingId fn = True -- See Note [isCheapApp: bottoming functions] | otherwise = case idDetails fn of- DataConWorkId {} -> True+ DataConWorkId {} -> True -- Actually handled by isWorkFreeApp RecSelId {} -> n_val_args == 1 -- See Note [Record selection] ClassOpId {} -> n_val_args == 1 PrimOpId op -> primOpIsCheap op@@ -1201,21 +1200,24 @@ isExpandableApp :: CheapAppFun isExpandableApp fn n_val_args- | notRedex fn n_val_args- = True- | isConLikeId fn- = True+ | isWorkFreeApp fn n_val_args = True | otherwise = case idDetails fn of- DataConWorkId {} -> True+ DataConWorkId {} -> True -- Actually handled by isWorkFreeApp RecSelId {} -> n_val_args == 1 -- See Note [Record selection] ClassOpId {} -> n_val_args == 1 PrimOpId {} -> False- _ -> all_pred_args n_val_args (idType fn)+ _ | isBottomingId fn -> False+ -- See Note [isExpandableApp: bottoming functions]+ | isConLike (idRuleMatchInfo fn) -> True+ | all_args_are_preds -> True+ | otherwise -> False where- -- See if all the arguments are PredTys (implicit params or classes)- -- If so we'll regard it as expandable; see Note [Expandable overloadings]+ -- See if all the arguments are PredTys (implicit params or classes)+ -- If so we'll regard it as expandable; see Note [Expandable overloadings]+ all_args_are_preds = all_pred_args n_val_args (idType fn)+ all_pred_args n_val_args ty | n_val_args == 0 = True@@ -1228,7 +1230,35 @@ | otherwise = False -{- Note [Record selection]+{- Note [isCheapApp: bottoming functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+I'm not sure why we have a special case for bottoming+functions in isCheapApp. Maybe we don't need it.++Note [isExpandableApp: bottoming functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's important that isExpandableApp does not respond True to bottoming+functions. Recall undefined :: HasCallStack => a+Suppose isExpandableApp responded True to (undefined d), and we had:++ x = undefined <dict-expr>++Then Simplify.prepareRhs would ANF the RHS:++ d = <dict-expr>+ x = undefined d++This is already bad: we gain nothing from having x bound to (undefined+var), unlike the case for data constructors. Worse, we get the+simplifier loop described in OccurAnal Note [Cascading inlines].+Suppose x occurs just once; OccurAnal.occAnalNonRecRhs decides x will+certainly_inline; so we end up inlining d right back into x; but in+the end x doesn't inline because it is bottom (preInlineUnconditionally);+so the process repeats.. We could elaborate the certainly_inline logic+some more, but it's better just to treat bottoming bindings as+non-expandable, because ANFing them is a bad idea in the first place.++Note [Record selection] ~~~~~~~~~~~~~~~~~~~~~~~~~~ I'm experimenting with making record selection look cheap, so we will substitute it inside a@@ -1285,7 +1315,7 @@ -- exprOkForSpeculation implies exprOkForSideEffects -- -- See Note [PrimOp can_fail and has_side_effects] in PrimOp--- and Note [Implementation: how can_fail/has_side_effects affect transformations]+-- and Note [Transformations affected by can_fail and has_side_effects] -- -- As an example of the considerations in this test, consider: --@@ -1301,11 +1331,10 @@ -- -- We can only do this if the @y + 1@ is ok for speculation: it has no -- side effects, and can't diverge or raise an exception.+ exprOkForSpeculation, exprOkForSideEffects :: CoreExpr -> Bool exprOkForSpeculation = expr_ok primOpOkForSpeculation exprOkForSideEffects = expr_ok primOpOkForSideEffects- -- Polymorphic in binder type- -- There is one call at a non-Id binder type, in SetLevels expr_ok :: (PrimOp -> Bool) -> CoreExpr -> Bool expr_ok _ (Lit _) = True@@ -1326,10 +1355,18 @@ | tickishCounts tickish = False | otherwise = expr_ok primop_ok e -expr_ok primop_ok (Case e _ _ alts)- = expr_ok primop_ok e -- Note [exprOkForSpeculation: case expressions]+expr_ok _ (Let {}) = False+ -- Lets can be stacked deeply, so just give up.+ -- In any case, the argument of exprOkForSpeculation is+ -- usually in a strict context, so any lets will have been+ -- floated away.++expr_ok primop_ok (Case scrut bndr _ alts)+ = -- See Note [exprOkForSpeculation: case expressions]+ expr_ok primop_ok scrut+ && isUnliftedType (idType bndr) && all (\(_,_,rhs) -> expr_ok primop_ok rhs) alts- && altsAreExhaustive alts -- Note [Exhaustive alts]+ && altsAreExhaustive alts expr_ok primop_ok other_expr = case collectArgs other_expr of@@ -1390,7 +1427,7 @@ = case con1 of DEFAULT -> True LitAlt {} -> False- DataAlt c -> 1 + length alts == tyConFamilySize (dataConTyCon c)+ DataAlt c -> alts `lengthIs` (tyConFamilySize (dataConTyCon c) - 1) -- It is possible to have an exhaustive case that does not -- enumerate all constructors, notably in a GADT match, but -- we behave conservatively here -- I don't think it's important@@ -1409,22 +1446,72 @@ isDivOp DoubleDivOp = True isDivOp _ = False -{--Note [exprOkForSpeculation: case expressions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's always sound for exprOkForSpeculation to return False, and we-don't want it to take too long, so it bales out on complicated-looking-terms. Notably lets, which can be stacked very deeply; and in any-case the argument of exprOkForSpeculation is usually in a strict context,-so any lets will have been floated away.+{- Note [exprOkForSpeculation: case expressions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+exprOkForSpeculation accepts very special case expressions.+Reason: (a ==# b) is ok-for-speculation, but the litEq rules+in PrelRules convert it (a ==# 3#) to+ case a of { DEAFULT -> 0#; 3# -> 1# }+for excellent reasons described in+ PrelRules Note [The litEq rule: converting equality to case].+So, annoyingly, we want that case expression to be+ok-for-speculation too. Bother. -However, we keep going on case-expressions. An example like this one-showed up in DPH code (Trac #3717):+But we restrict it sharply:++* We restrict it to unlifted scrutinees. Consider this:+ case x of y {+ DEFAULT -> ... (let v::Int# = case y of { True -> e1+ ; False -> e2 }+ in ...) ...++ Does the RHS of v satisfy the let/app invariant? Previously we said+ yes, on the grounds that y is evaluated. But the binder-swap done+ by SetLevels would transform the inner alternative to+ DEFAULT -> ... (let v::Int# = case x of { ... }+ in ...) ....+ which does /not/ satisfy the let/app invariant, because x is+ not evaluated. See Note [Binder-swap during float-out]+ in SetLevels. To avoid this awkwardness it seems simpler+ to stick to unlifted scrutinees where the issue does not+ arise.++* We restrict it to exhaustive alternatives. A non-exhaustive+ case manifestly isn't ok-for-speculation. Consider+ case e of x { DEAFULT ->+ ...(case x of y+ A -> ...+ _ -> ...(case (case x of { B -> p; C -> p }) of+ I# r -> blah)...+ If SetLevesls considers the inner nested case as ok-for-speculation+ it can do case-floating (see Note [Floating cases] in SetLevels).+ So we'd float to:+ case e of x { DEAFULT ->+ case (case x of { B -> p; C -> p }) of I# r ->+ ...(case x of y+ A -> ...+ _ -> ...blah...)...+ which is utterly bogus (seg fault); see Trac #5453.++ Similarly, this is a valid program (albeit a slightly dodgy one)+ let v = case x of { B -> ...; C -> ... }+ in case x of+ A -> ...+ _ -> ...v...v....+ Should v be considered ok-for-speculation? Its scrutinee may be+ evaluated, but the alternatives are incomplete so we should not+ evalutate it strictly.++ Now, all this is for lifted types, but it'd be the same for any+ finite unlifted type. We don't have many of them, but we might+ add unlifted algebraic types in due course.++----- Historical note: Trac #3717: -------- foo :: Int -> Int foo 0 = 0 foo n = (if n < 5 then 1 else 2) `seq` foo (n-1) -If exprOkForSpeculation doesn't look through case expressions, you get this:+In earlier GHCs, we got this: T.$wfoo = \ (ww :: GHC.Prim.Int#) -> case ww of ds {@@ -1433,31 +1520,13 @@ GHC.Types.True -> lvl}) of _ { __DEFAULT -> T.$wfoo (GHC.Prim.-# ds_XkE 1) };- 0 -> 0- }--The inner case is redundant, and should be nuked.--Note [Exhaustive alts]-~~~~~~~~~~~~~~~~~~~~~~-We might have something like- case x of {- A -> ...- _ -> ...(case x of { B -> ...; C -> ... })...-Here, the inner case is fine, because the A alternative-can't happen, but it's not ok to float the inner case outside-the outer one (even if we know x is evaluated outside), because-then it would be non-exhaustive. See Trac #5453.--Similarly, this is a valid program (albeit a slightly dodgy one)- let v = case x of { B -> ...; C -> ... }- in case x of- A -> ...- _ -> ...v...v....-But we don't want to speculate the v binding.+ 0 -> 0 } -One could try to be clever, but the easy fix is simpy to regard-a non-exhaustive case as *not* okForSpeculation.+Before join-points etc we could only get rid of two cases (which are+redundant) by recognising that th e(case <# ds 5 of { ... }) is+ok-for-speculation, even though it has /lifted/ type. But now join+points do the job nicely.+------- End of historical note ------------ Note [Primops with lifted arguments]@@ -1544,9 +1613,9 @@ exprIsHNFlike is_con is_con_unf = is_hnf_like where is_hnf_like (Var v) -- NB: There are no value args at this point- = is_con v -- Catches nullary constructors,- -- so that [] and () are values, for example- || idArity v > 0 -- Catches (e.g.) primops that don't have unfoldings+ = id_app_is_value v 0 -- Catches nullary constructors,+ -- so that [] and () are values, for example+ -- and (e.g.) primops that don't have unfoldings || is_con_unf (idUnfolding v) -- Check the thing's unfolding; it might be bound to a value -- We don't look through loop breakers here, which is a bit conservative@@ -1559,7 +1628,7 @@ is_hnf_like (Coercion _) = True -- Same for coercions is_hnf_like (Lam b e) = isRuntimeVar b || is_hnf_like e is_hnf_like (Tick tickish e) = not (tickishCounts tickish)- && is_hnf_like e+ && is_hnf_like e -- See Note [exprIsHNF Tick] is_hnf_like (Cast e _) = is_hnf_like e is_hnf_like (App e a)@@ -1787,7 +1856,7 @@ && go (rnBndr2 env v1 v2) e1 e2 go env (Let (Rec ps1) e1) (Let (Rec ps2) e2)- = length ps1 == length ps2+ = equalLength ps1 ps2 && all2 (go env') rs1 rs2 && go env' e1 e2 where (bs1,rs1) = unzip ps1@@ -1842,7 +1911,7 @@ = let (ds, env') = diffBinds top env (flattenBinds [bs1]) (flattenBinds [bs2]) in ds ++ diffExpr top env' e1 e2 diffExpr top env (Case e1 b1 t1 a1) (Case e2 b2 t2 a2)- | length a1 == length a2 && not (null a1) || eqTypeX env t1 t2+ | equalLength a1 a2 && not (null a1) || eqTypeX env t1 t2 -- See Note [Empty case alternatives] in TrieMap = diffExpr top env e1 e2 ++ concat (zipWith diffAlt a1 a2) where env' = rnBndr2 env b1 b2@@ -1937,7 +2006,7 @@ diffUnfold _ (OtherCon cs1) (OtherCon cs2) | cs1 == cs2 = [] diffUnfold env (DFunUnfolding bs1 c1 a1) (DFunUnfolding bs2 c2 a2)- | c1 == c2 && length bs1 == length bs2+ | c1 == c2 && equalLength bs1 bs2 = concatMap (uncurry (diffExpr False env')) (zip a1 a2) where env' = rnBndrs2 env bs1 bs2 diffUnfold env (CoreUnfolding t1 _ _ v1 cl1 wf1 x1 g1)
coreSyn/MkCore.hs view
@@ -51,6 +51,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Id import Var ( EvVar, setTyVarUnique ) @@ -116,34 +118,43 @@ mkCoreLets binds body = foldr mkCoreLet body binds -- | Construct an expression which represents the application of one expression+-- paired with its type to an argument. The result is paired with its type. This+-- function is not exported and used in the definition of 'mkCoreApp' and+-- 'mkCoreApps'.+-- Respects the let/app invariant by building a case expression where necessary+-- See CoreSyn Note [CoreSyn let/app invariant]+mkCoreAppTyped :: SDoc -> (CoreExpr, Type) -> CoreExpr -> (CoreExpr, Type)+mkCoreAppTyped _ (fun, fun_ty) (Type ty)+ = (App fun (Type ty), piResultTy fun_ty ty)+mkCoreAppTyped _ (fun, fun_ty) (Coercion co)+ = (App fun (Coercion co), res_ty)+ where+ (_, res_ty) = splitFunTy fun_ty+mkCoreAppTyped d (fun, fun_ty) arg+ = ASSERT2( isFunTy fun_ty, ppr fun $$ ppr arg $$ d )+ (mk_val_app fun arg arg_ty res_ty, res_ty)+ where+ (arg_ty, res_ty) = splitFunTy fun_ty++-- | Construct an expression which represents the application of one expression -- to the other-mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr -- Respects the let/app invariant by building a case expression where necessary -- See CoreSyn Note [CoreSyn let/app invariant]-mkCoreApp _ fun (Type ty) = App fun (Type ty)-mkCoreApp _ fun (Coercion co) = App fun (Coercion co)-mkCoreApp d fun arg = ASSERT2( isFunTy fun_ty, ppr fun $$ ppr arg $$ d )- mk_val_app fun arg arg_ty res_ty- where- fun_ty = exprType fun- (arg_ty, res_ty) = splitFunTy fun_ty+mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr+mkCoreApp s fun arg+ = fst $ mkCoreAppTyped s (fun, exprType fun) arg -- | Construct an expression which represents the application of a number of -- expressions to another. The leftmost expression in the list is applied first -- Respects the let/app invariant by building a case expression where necessary -- See CoreSyn Note [CoreSyn let/app invariant] mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr--- Slightly more efficient version of (foldl mkCoreApp)-mkCoreApps orig_fun orig_args- = go orig_fun (exprType orig_fun) orig_args+mkCoreApps fun args+ = fst $+ foldl' (mkCoreAppTyped doc_string) (fun, fun_ty) args where- go fun _ [] = fun- go fun fun_ty (Type ty : args) = go (App fun (Type ty)) (piResultTy fun_ty ty) args- go fun fun_ty (arg : args) = ASSERT2( isFunTy fun_ty, ppr fun_ty $$ ppr orig_fun- $$ ppr orig_args )- go (mk_val_app fun arg arg_ty res_ty) res_ty args- where- (arg_ty, res_ty) = splitFunTy fun_ty+ doc_string = ppr fun_ty $$ ppr fun $$ ppr args+ fun_ty = exprType fun -- | Construct an expression which represents the application of a number of -- expressions to that of a data constructor expression. The leftmost expression@@ -859,4 +870,3 @@ = mkApps (Var aBSENT_ERROR_ID) [ Type res_ty, err_string ] where err_string = Lit (mkMachString err_msg)-
coreSyn/PprCore.hs view
@@ -15,6 +15,8 @@ pprRules, pprOptCo ) where +import GhcPrelude+ import CoreSyn import CoreStats (exprStats) import Literal( pprLiteral )@@ -213,7 +215,7 @@ ] else add_par $ sep [sep [sep [ text "case" <+> pprCoreExpr expr- , ifPprDebug (text "return" <+> ppr ty)+ , whenPprDebug (text "return" <+> ppr ty) , text "of" <+> ppr_bndr var ] , char '{' <+> ppr_case_pat con args <+> arrow@@ -228,7 +230,7 @@ = add_par $ sep [sep [text "case" <+> pprCoreExpr expr- <+> ifPprDebug (text "return" <+> ppr ty),+ <+> whenPprDebug (text "return" <+> ppr ty), text "of" <+> ppr_bndr var <+> char '{'], nest 2 (vcat (punctuate semi (map pprCoreAlt alts))), char '}'@@ -374,7 +376,7 @@ = sdocWithDynFlags $ \dflags -> case () of _- | not debug_on -- Show case-bound wild bilders only if debug is on+ | not debug_on -- Show case-bound wild binders only if debug is on , CaseBind <- bind_site , isDeadBinder var -> empty
coreSyn/TrieMap.hs view
@@ -31,6 +31,8 @@ (>.>), (|>), (|>>), ) where +import GhcPrelude+ import CoreSyn import Coercion import Literal@@ -41,6 +43,7 @@ import UniqDFM import Unique( Unique ) import FastString(FastString)+import Util import qualified Data.Map as Map import qualified Data.IntMap as IntMap@@ -277,6 +280,9 @@ foldTM = fdList mapTM = mapList +instance (TrieMap m, Outputable a) => Outputable (ListMap m a) where+ ppr m = text "List elts" <+> ppr (foldTM (:) m [])+ mapList :: TrieMap m => (a->b) -> ListMap m a -> ListMap m b mapList f (LM { lm_nil = mnil, lm_cons = mcons }) = LM { lm_nil = fmap f mnil, lm_cons = mapTM (mapTM f) mcons }@@ -446,7 +452,7 @@ rather than cm_lam :: TypeMapG (CoreMapG a) - * We don't need to look at the type of some binders, notalby+ * We don't need to look at the type of some binders, notably - the case binder in (Case _ b _ _) - the binders in an alternative because they are totally fixed by the context@@ -526,7 +532,7 @@ && D (extendCME env1 v1) e1 == D (extendCME env2 v2) e2 go (Let (Rec ps1) e1) (Let (Rec ps2) e2)- = length ps1 == length ps2+ = equalLength ps1 ps2 && D env1' rs1 == D env2' rs2 && D env1' e1 == D env2' e2 where
deSugar/Check.hs view
@@ -12,13 +12,19 @@ checkSingle, checkMatches, isAnyPmCheckEnabled, -- See Note [Type and Term Equality Propagation]- genCaseTmCs1, genCaseTmCs2+ genCaseTmCs1, genCaseTmCs2,++ -- Pattern-match-specific type operations+ pmIsClosedType, pmTopNormaliseType_maybe ) where #include "HsVersions.h" -import TmOracle+import GhcPrelude +import TmOracle+import Unify( tcMatchTy )+import BasicTypes import DynFlags import HsSyn import TcHsSyn@@ -26,6 +32,7 @@ import ConLike import Name import FamInstEnv+import TysPrim (tYPETyCon) import TysWiredIn import TyCon import SrcLoc@@ -41,9 +48,11 @@ import Bag import ErrUtils import Var (EvVar)+import TyCoRep import Type import UniqSupply import DsGRHSs (isTrueLHsExpr)+import Maybes ( expectJust ) import Data.List (find) import Data.Maybe (isJust, fromMaybe)@@ -51,6 +60,7 @@ import Coercion import TcEvidence import IOEnv+import qualified Data.Semigroup as Semi import ListT (ListT(..), fold, select) @@ -91,36 +101,37 @@ -- Pick the first match complete covered match or otherwise the "best" match. -- The best match is the one with the least uncovered clauses, ties broken--- by the number of inaccessible clauses followed by number of redudant--- clauses+-- by the number of inaccessible clauses followed by number of redundant+-- clauses.+--+-- This is specified in the+-- "Disambiguating between multiple ``COMPLETE`` pragmas" section of the+-- users' guide. If you update the implementation of this function, make sure+-- to update that section of the users' guide as well. getResult :: PmM PmResult -> DsM PmResult-getResult ls = do- res <- fold ls goM (pure Nothing)- case res of- Nothing -> panic "getResult is empty"- Just a -> return a+getResult ls+ = do { res <- fold ls goM (pure Nothing)+ ; case res of+ Nothing -> panic "getResult is empty"+ Just a -> return a } where goM :: PmResult -> DsM (Maybe PmResult) -> DsM (Maybe PmResult)- goM mpm dpm = do- pmr <- dpm- return $ go pmr mpm+ goM mpm dpm = do { pmr <- dpm+ ; return $ Just $ go pmr mpm }+ -- Careful not to force unecessary results- go :: Maybe PmResult -> PmResult -> Maybe PmResult- go Nothing rs = Just rs- go old@(Just (PmResult prov rs (UncoveredPatterns us) is)) new+ go :: Maybe PmResult -> PmResult -> PmResult+ go Nothing rs = rs+ go (Just old@(PmResult prov rs (UncoveredPatterns us) is)) new | null us && null rs && null is = old | otherwise = let PmResult prov' rs' (UncoveredPatterns us') is' = new- lr = length rs- lr' = length rs'- li = length is- li' = length is'- in case compare (length us) (length us')- `mappend` (compare li li')- `mappend` (compare lr lr')+ in case compareLength us us'+ `mappend` (compareLength is is')+ `mappend` (compareLength rs rs') `mappend` (compare prov prov') of- GT -> Just new- EQ -> Just new+ GT -> new+ EQ -> new LT -> old go (Just (PmResult _ _ (TypeOfUncovered _) _)) _new = panic "getResult: No inhabitation candidates"@@ -137,7 +148,7 @@ , pm_con_dicts :: [EvVar] , pm_con_args :: [PmPat t] } -> PmPat t -- For PmCon arguments' meaning see @ConPatOut@ in hsSyn/HsPat.hs- PmVar :: { pm_var_id :: Id } -> PmPat t+ PmVar :: { pm_var_id :: Id } -> PmPat t PmLit :: { pm_lit_lit :: PmLit } -> PmPat t -- See Note [Literals in PmPat] PmNLit :: { pm_lit_id :: Id , pm_lit_not :: [PmLit] } -> PmPat 'VA@@ -183,11 +194,14 @@ -- Like the or monoid for booleans -- Covered = True, Uncovered = False+instance Semi.Semigroup Covered where+ Covered <> _ = Covered+ _ <> Covered = Covered+ NotCovered <> NotCovered = NotCovered+ instance Monoid Covered where mempty = NotCovered- Covered `mappend` _ = Covered- _ `mappend` Covered = Covered- NotCovered `mappend` NotCovered = NotCovered+ mappend = (Semi.<>) data Diverged = Diverged | NotDiverged deriving Show@@ -196,11 +210,14 @@ ppr Diverged = text "Diverged" ppr NotDiverged = text "NotDiverged" +instance Semi.Semigroup Diverged where+ Diverged <> _ = Diverged+ _ <> Diverged = Diverged+ NotDiverged <> NotDiverged = NotDiverged+ instance Monoid Diverged where mempty = NotDiverged- Diverged `mappend` _ = Diverged- _ `mappend` Diverged = Diverged- NotDiverged `mappend` NotDiverged = NotDiverged+ mappend = (Semi.<>) -- | When we learned that a given match group is complete data Provenance =@@ -212,17 +229,20 @@ instance Outputable Provenance where ppr = text . show +instance Semi.Semigroup Provenance where+ FromComplete <> _ = FromComplete+ _ <> FromComplete = FromComplete+ _ <> _ = FromBuiltin+ instance Monoid Provenance where mempty = FromBuiltin- FromComplete `mappend` _ = FromComplete- _ `mappend` FromComplete = FromComplete- _ `mappend` _ = FromBuiltin+ mappend = (Semi.<>) data PartialResult = PartialResult {- presultProvenence :: Provenance+ presultProvenance :: Provenance -- keep track of provenance because we don't want -- to warn about redundant matches if the result- -- is contaiminated with a COMPLETE pragma+ -- is contaminated with a COMPLETE pragma , presultCovered :: Covered , presultUncovered :: Uncovered , presultDivergent :: Diverged }@@ -232,14 +252,19 @@ = text "PartialResult" <+> ppr prov <+> ppr c <+> ppr d <+> ppr vsa ++instance Semi.Semigroup PartialResult where+ (PartialResult prov1 cs1 vsa1 ds1)+ <> (PartialResult prov2 cs2 vsa2 ds2)+ = PartialResult (prov1 Semi.<> prov2)+ (cs1 Semi.<> cs2)+ (vsa1 Semi.<> vsa2)+ (ds1 Semi.<> ds2)++ instance Monoid PartialResult where mempty = PartialResult mempty mempty [] mempty- (PartialResult prov1 cs1 vsa1 ds1)- `mappend` (PartialResult prov2 cs2 vsa2 ds2)- = PartialResult (prov1 `mappend` prov2)- (cs1 `mappend` cs2)- (vsa1 `mappend` vsa2)- (ds1 `mappend` ds2)+ mappend = (Semi.<>) -- newtype ChoiceOf a = ChoiceOf [a] @@ -256,10 +281,10 @@ -- data PmResult = PmResult {- pmresultProvenance :: Provenance- , pmresultRedundant :: [Located [LPat Id]]- , pmresultUncovered :: UncoveredCandidates- , pmresultInaccessible :: [Located [LPat Id]] }+ pmresultProvenance :: Provenance+ , pmresultRedundant :: [Located [LPat GhcTc]]+ , pmresultUncovered :: UncoveredCandidates+ , pmresultInaccessible :: [Located [LPat GhcTc]] } -- | Either a list of patterns that are not covered, or their type, in case we -- have no patterns at hand. Not having patterns at hand can arise when@@ -292,7 +317,7 @@ -} -- | Check a single pattern binding (let)-checkSingle :: DynFlags -> DsMatchContext -> Id -> Pat Id -> DsM ()+checkSingle :: DynFlags -> DsMatchContext -> Id -> Pat GhcTc -> DsM () checkSingle dflags ctxt@(DsMatchContext _ locn) var p = do tracePmD "checkSingle" (vcat [ppr ctxt, ppr var, ppr p]) mb_pm_res <- tryM (getResult (checkSingle' locn var p))@@ -301,7 +326,7 @@ Right res -> dsPmWarn dflags ctxt res -- | Check a single pattern binding (let)-checkSingle' :: SrcSpan -> Id -> Pat Id -> PmM PmResult+checkSingle' :: SrcSpan -> Id -> Pat GhcTc -> PmM PmResult checkSingle' locn var p = do liftD resetPmIterDs -- set the iter-no to zero fam_insts <- liftD dsGetFamInstEnvs@@ -319,7 +344,7 @@ -- | Check a matchgroup (case, functions, etc.) checkMatches :: DynFlags -> DsMatchContext- -> [Id] -> [LMatch Id (LHsExpr Id)] -> DsM ()+ -> [Id] -> [LMatch GhcTc (LHsExpr GhcTc)] -> DsM () checkMatches dflags ctxt vars matches = do tracePmD "checkMatches" (hang (vcat [ppr ctxt , ppr vars@@ -337,7 +362,7 @@ -- | Check a matchgroup (case, functions, etc.). To be called on a non-empty -- list of matches. For empty case expressions, use checkEmptyCase' instead.-checkMatches' :: [Id] -> [LMatch Id (LHsExpr Id)] -> PmM PmResult+checkMatches' :: [Id] -> [LMatch GhcTc (LHsExpr GhcTc)] -> PmM PmResult checkMatches' vars matches | null matches = panic "checkMatches': EmptyCase" | otherwise = do@@ -351,11 +376,11 @@ , pmresultUncovered = UncoveredPatterns us , pmresultInaccessible = map hsLMatchToLPats ds } where- go :: [LMatch Id (LHsExpr Id)] -> Uncovered+ go :: [LMatch GhcTc (LHsExpr GhcTc)] -> Uncovered -> PmM (Provenance- , [LMatch Id (LHsExpr Id)]+ , [LMatch GhcTc (LHsExpr GhcTc)] , Uncovered- , [LMatch Id (LHsExpr Id)])+ , [LMatch GhcTc (LHsExpr GhcTc)]) go [] missing = return (mempty, [], missing, []) go (m:ms) missing = do tracePm "checMatches': go" (ppr m $$ ppr missing)@@ -375,7 +400,7 @@ (NotCovered, Diverged ) -> (final_prov, rs, final_u, m:is) hsLMatchToLPats :: LMatch id body -> Located [LPat id]- hsLMatchToLPats (L l (Match _ pats _ _)) = L l pats+ hsLMatchToLPats (L l (Match { m_pats = pats })) = L l pats -- | Check an empty case expression. Since there are no clauses to process, we -- only compute the uncovered set. See Note [Checking EmptyCase Expressions]@@ -409,10 +434,151 @@ else PmResult FromBuiltin [] uncovered [] Nothing -> return emptyPmResult +-- | Returns 'True' if the argument 'Type' is a fully saturated application of+-- a closed type constructor.+--+-- Closed type constructors are those with a fixed right hand side, as+-- opposed to e.g. associated types. These are of particular interest for+-- pattern-match coverage checking, because GHC can exhaustively consider all+-- possible forms that values of a closed type can take on.+--+-- Note that this function is intended to be used to check types of value-level+-- patterns, so as a consequence, the 'Type' supplied as an argument to this+-- function should be of kind @Type@.+pmIsClosedType :: Type -> Bool+pmIsClosedType ty+ = case splitTyConApp_maybe ty of+ Just (tc, ty_args)+ | is_algebraic_like tc && not (isFamilyTyCon tc)+ -> ASSERT2( ty_args `lengthIs` tyConArity tc, ppr ty ) True+ _other -> False+ where+ -- This returns True for TyCons which /act like/ algebraic types.+ -- (See "Type#type_classification" for what an algebraic type is.)+ --+ -- This is qualified with \"like\" because of a particular special+ -- case: TYPE (the underlyind kind behind Type, among others). TYPE+ -- is conceptually a datatype (and thus algebraic), but in practice it is+ -- a primitive builtin type, so we must check for it specially.+ --+ -- NB: it makes sense to think of TYPE as a closed type in a value-level,+ -- pattern-matching context. However, at the kind level, TYPE is certainly+ -- not closed! Since this function is specifically tailored towards pattern+ -- matching, however, it's OK to label TYPE as closed.+ is_algebraic_like :: TyCon -> Bool+ is_algebraic_like tc = isAlgTyCon tc || tc == tYPETyCon++pmTopNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe (Type, [DataCon], Type)+-- ^ Get rid of *outermost* (or toplevel)+-- * type function redex+-- * data family redex+-- * newtypes+--+-- Behaves exactly like `topNormaliseType_maybe`, but instead of returning a+-- coercion, it returns useful information for issuing pattern matching+-- warnings. See Note [Type normalisation for EmptyCase] for details.+pmTopNormaliseType_maybe env typ+ = do ((ty_f,tm_f), ty) <- topNormaliseTypeX stepper comb typ+ return (eq_src_ty ty (typ : ty_f [ty]), tm_f [], ty)+ where+ -- Find the first type in the sequence of rewrites that is a data type,+ -- newtype, or a data family application (not the representation tycon!).+ -- This is the one that is equal (in source Haskell) to the initial type.+ -- If none is found in the list, then all of them are type family+ -- applications, so we simply return the last one, which is the *simplest*.+ eq_src_ty :: Type -> [Type] -> Type+ eq_src_ty ty tys = maybe ty id (find is_closed_or_data_family tys)++ is_closed_or_data_family :: Type -> Bool+ is_closed_or_data_family ty = pmIsClosedType ty || isDataFamilyAppType ty++ -- For efficiency, represent both lists as difference lists.+ -- comb performs the concatenation, for both lists.+ comb (tyf1, tmf1) (tyf2, tmf2) = (tyf1 . tyf2, tmf1 . tmf2)++ stepper = newTypeStepper `composeSteppers` tyFamStepper++ -- A 'NormaliseStepper' that unwraps newtypes, careful not to fall into+ -- a loop. If it would fall into a loop, it produces 'NS_Abort'.+ newTypeStepper :: NormaliseStepper ([Type] -> [Type],[DataCon] -> [DataCon])+ newTypeStepper rec_nts tc tys+ | Just (ty', _co) <- instNewTyCon_maybe tc tys+ = case checkRecTc rec_nts tc of+ Just rec_nts' -> let tyf = ((TyConApp tc tys):)+ tmf = ((tyConSingleDataCon tc):)+ in NS_Step rec_nts' ty' (tyf, tmf)+ Nothing -> NS_Abort+ | otherwise+ = NS_Done++ tyFamStepper :: NormaliseStepper ([Type] -> [Type], [DataCon] -> [DataCon])+ tyFamStepper rec_nts tc tys -- Try to step a type/data family+ = let (_args_co, ntys) = normaliseTcArgs env Representational tc tys in+ -- NB: It's OK to use normaliseTcArgs here instead of+ -- normalise_tc_args (which takes the LiftingContext described+ -- in Note [Normalising types]) because the reduceTyFamApp below+ -- works only at top level. We'll never recur in this function+ -- after reducing the kind of a bound tyvar.++ case reduceTyFamApp_maybe env Representational tc ntys of+ Just (_co, rhs) -> NS_Step rec_nts rhs ((rhs:), id)+ _ -> NS_Done++{- Note [Type normalisation for EmptyCase]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+EmptyCase is an exception for pattern matching, since it is strict. This means+that it boils down to checking whether the type of the scrutinee is inhabited.+Function pmTopNormaliseType_maybe gets rid of the outermost type function/data+family redex and newtypes, in search of an algebraic type constructor, which is+easier to check for inhabitation.++It returns 3 results instead of one, because there are 2 subtle points:+1. Newtypes are isomorphic to the underlying type in core but not in the source+ language,+2. The representational data family tycon is used internally but should not be+ shown to the user++Hence, if pmTopNormaliseType_maybe env ty = Just (src_ty, dcs, core_ty), then+ (a) src_ty is the rewritten type which we can show to the user. That is, the+ type we get if we rewrite type families but not data families or+ newtypes.+ (b) dcs is the list of data constructors "skipped", every time we normalise a+ newtype to it's core representation, we keep track of the source data+ constructor.+ (c) core_ty is the rewritten type. That is,+ pmTopNormaliseType_maybe env ty = Just (src_ty, dcs, core_ty)+ implies+ topNormaliseType_maybe env ty = Just (co, core_ty)+ for some coercion co.++To see how all cases come into play, consider the following example:++ data family T a :: *+ data instance T Int = T1 | T2 Bool+ -- Which gives rise to FC:+ -- data T a+ -- data R:TInt = T1 | T2 Bool+ -- axiom ax_ti : T Int ~R R:TInt++ newtype G1 = MkG1 (T Int)+ newtype G2 = MkG2 G1++ type instance F Int = F Char+ type instance F Char = G2++In this case pmTopNormaliseType_maybe env (F Int) results in++ Just (G2, [MkG2,MkG1], R:TInt)++Which means that in source Haskell:+ - G2 is equivalent to F Int (in contrast, G1 isn't).+ - if (x : R:TInt) then (MkG2 (MkG1 x) : F Int).+-}+ -- | Generate all inhabitation candidates for a given type. The result is -- either (Left ty), if the type cannot be reduced to a closed algebraic type -- (or if it's one trivially inhabited, like Int), or (Right candidates), if it--- can. In this case, the candidates are the singnature of the tycon, each one+-- can. In this case, the candidates are the signature of the tycon, each one -- accompanied by the term- and type- constraints it gives rise to. -- See also Note [Checking EmptyCase Expressions] inhabitationCandidates :: FamInstEnvs -> Type@@ -442,7 +608,8 @@ (_:_) -> do var <- liftD $ mkPmId (toTcType core_ty) let va = build_tm (PmVar var) dcs return $ Right [(va, mkIdEq var, emptyBag)]- | isClosedAlgType core_ty -> liftD $ do++ | pmIsClosedType core_ty -> liftD $ do var <- mkPmId (toTcType core_ty) -- it would be wrong to unify x alts <- mapM (mkOneConFull var . RealDataCon) (tyConDataCons tc) return $ Right [(build_tm va dcs, eq, cs) | (va, eq, cs) <- alts]@@ -547,14 +714,14 @@ {-# INLINE mkListPatVec #-} -- | Create a (non-overloaded) literal pattern-mkLitPattern :: HsLit -> Pattern+mkLitPattern :: HsLit GhcTc -> Pattern mkLitPattern lit = PmLit { pm_lit_lit = PmSLit lit } {-# INLINE mkLitPattern #-} -- ----------------------------------------------------------------------- -- * Transform (Pat Id) into of (PmPat Id) -translatePat :: FamInstEnvs -> Pat Id -> DsM PatVec+translatePat :: FamInstEnvs -> Pat GhcTc -> DsM PatVec translatePat fam_insts pat = case pat of WildPat ty -> mkPmVars [ty] VarPat id -> return [PmVar (unLoc id)]@@ -580,7 +747,7 @@ | otherwise -> do ps <- translatePat fam_insts p (xp,xe) <- mkPmId2Forms ty- let g = mkGuard ps (HsWrap wrapper (unLoc xe))+ let g = mkGuard ps (mkHsWrap wrapper (unLoc xe)) return [xp,g] -- (n + k) ===> x (True <- x >= k) (n <- x-k)@@ -664,30 +831,36 @@ -- | Translate an overloaded literal (see `tidyNPat' in deSugar/MatchLit.hs) translateNPat :: FamInstEnvs- -> HsOverLit Id -> Maybe (SyntaxExpr Id) -> Type -> DsM PatVec+ -> HsOverLit GhcTc -> Maybe (SyntaxExpr GhcTc) -> Type+ -> DsM PatVec translateNPat fam_insts (OverLit val False _ ty) mb_neg outer_ty | not type_change, isStringTy ty, HsIsString src s <- val, Nothing <- mb_neg = translatePat fam_insts (LitPat (HsString src s))- | not type_change, isIntTy ty, HsIntegral src i <- val- = translatePat fam_insts (mk_num_lit HsInt src i)- | not type_change, isWordTy ty, HsIntegral src i <- val- = translatePat fam_insts (mk_num_lit HsWordPrim src i)+ | not type_change, isIntTy ty, HsIntegral i <- val+ = translatePat fam_insts+ (LitPat $ case mb_neg of+ Nothing -> HsInt def i+ Just _ -> HsInt def (negateIntegralLit i))+ | not type_change, isWordTy ty, HsIntegral i <- val+ = translatePat fam_insts+ (LitPat $ case mb_neg of+ Nothing -> HsWordPrim (il_text i) (il_value i)+ Just _ -> let ni = negateIntegralLit i in+ HsWordPrim (il_text ni) (il_value ni)) where type_change = not (outer_ty `eqType` ty)- mk_num_lit c src i = LitPat $ case mb_neg of- Nothing -> c src i- Just _ -> c src (-i)+ translateNPat _ ol mb_neg _ = return [PmLit { pm_lit_lit = PmOLit (isJust mb_neg) ol }] -- | Translate a list of patterns (Note: each pattern is translated -- to a pattern vector but we do not concatenate the results).-translatePatVec :: FamInstEnvs -> [Pat Id] -> DsM [PatVec]+translatePatVec :: FamInstEnvs -> [Pat GhcTc] -> DsM [PatVec] translatePatVec fam_insts pats = mapM (translatePat fam_insts) pats -- | Translate a constructor pattern translateConPatVec :: FamInstEnvs -> [Type] -> [TyVar]- -> ConLike -> HsConPatDetails Id -> DsM PatVec+ -> ConLike -> HsConPatDetails GhcTc -> DsM PatVec translateConPatVec fam_insts _univ_tys _ex_tvs _ (PrefixCon ps) = concat <$> translatePatVec fam_insts (map unLoc ps) translateConPatVec fam_insts _univ_tys _ex_tvs _ (InfixCon p1 p2)@@ -703,7 +876,7 @@ -- Generate a simple constructor pattern and make up fresh variables for -- the rest of the fields | matched_lbls `subsetOf` orig_lbls- = ASSERT(length orig_lbls == length arg_tys)+ = ASSERT(orig_lbls `equalLength` arg_tys) let translateOne (lbl, ty) = case lookup lbl matched_pats of Just p -> translatePat fam_insts p Nothing -> mkPmVars [ty]@@ -742,13 +915,14 @@ | otherwise = subsetOf (x:xs) ys -- Translate a single match-translateMatch :: FamInstEnvs -> LMatch Id (LHsExpr Id) -> DsM (PatVec,[PatVec])-translateMatch fam_insts (L _ (Match _ lpats _ grhss)) = do+translateMatch :: FamInstEnvs -> LMatch GhcTc (LHsExpr GhcTc)+ -> DsM (PatVec,[PatVec])+translateMatch fam_insts (L _ (Match { m_pats = lpats, m_grhss = grhss })) = do pats' <- concat <$> translatePatVec fam_insts pats guards' <- mapM (translateGuards fam_insts) guards return (pats', guards') where- extractGuards :: LGRHS Id (LHsExpr Id) -> [GuardStmt Id]+ extractGuards :: LGRHS GhcTc (LHsExpr GhcTc) -> [GuardStmt GhcTc] extractGuards (L _ (GRHS gs _)) = map unLoc gs pats = map unLoc lpats@@ -758,7 +932,7 @@ -- * Transform source guards (GuardStmt Id) to PmPats (Pattern) -- | Translate a list of guard statements to a pattern vector-translateGuards :: FamInstEnvs -> [GuardStmt Id] -> DsM PatVec+translateGuards :: FamInstEnvs -> [GuardStmt GhcTc] -> DsM PatVec translateGuards fam_insts guards = do all_guards <- concat <$> mapM (translateGuard fam_insts) guards return (replace_unhandled all_guards)@@ -798,7 +972,7 @@ cantFailPattern _ = False -- | Translate a guard statement to Pattern-translateGuard :: FamInstEnvs -> GuardStmt Id -> DsM PatVec+translateGuard :: FamInstEnvs -> GuardStmt GhcTc -> DsM PatVec translateGuard fam_insts guard = case guard of BodyStmt e _ _ _ -> translateBoolGuard e LetStmt binds -> translateLet (unLoc binds)@@ -810,17 +984,17 @@ ApplicativeStmt {} -> panic "translateGuard ApplicativeLastStmt" -- | Translate let-bindings-translateLet :: HsLocalBinds Id -> DsM PatVec+translateLet :: HsLocalBinds GhcTc -> DsM PatVec translateLet _binds = return [] -- | Translate a pattern guard-translateBind :: FamInstEnvs -> LPat Id -> LHsExpr Id -> DsM PatVec+translateBind :: FamInstEnvs -> LPat GhcTc -> LHsExpr GhcTc -> DsM PatVec translateBind fam_insts (L _ p) e = do ps <- translatePat fam_insts p return [mkGuard ps (unLoc e)] -- | Translate a boolean guard-translateBoolGuard :: LHsExpr Id -> DsM PatVec+translateBoolGuard :: LHsExpr GhcTc -> DsM PatVec translateBoolGuard e | isJust (isTrueLHsExpr e) = return [] -- The formal thing to do would be to generate (True <- True)@@ -967,14 +1141,14 @@ -- ComplexEq: x ~ K y1..yn -- [EvVar]: Q mkOneConFull x con = do- let -- res_ty == TyConApp (ConLikeTyCon cabs_con) cabs_arg_tys- res_ty = idType x- (univ_tvs, ex_tvs, eq_spec, thetas, _req_theta , arg_tys, _)+ let res_ty = idType x+ (univ_tvs, ex_tvs, eq_spec, thetas, _req_theta , arg_tys, con_res_ty) = conLikeFullSig con- tc_args = case splitTyConApp_maybe res_ty of- Just (_, tys) -> tys- Nothing -> pprPanic "mkOneConFull: Not TyConApp:" (ppr res_ty)- subst1 = zipTvSubst univ_tvs tc_args+ tc_args = tyConAppArgs res_ty+ subst1 = case con of+ RealDataCon {} -> zipTvSubst univ_tvs tc_args+ PatSynCon {} -> expectJust "mkOneConFull" (tcMatchTy con_res_ty res_ty)+ -- See Note [Pattern synonym result type] in PatSyn (subst, ex_tvs') <- cloneTyVarBndrs subst1 ex_tvs <$> getUniqueSupplyM @@ -994,7 +1168,7 @@ -- * More smart constructors and fresh variable generation -- | Create a guard pattern-mkGuard :: PatVec -> HsExpr Id -> Pattern+mkGuard :: PatVec -> HsExpr GhcTc -> Pattern mkGuard pv e | all cantFailPattern pv = PmGrd pv expr | PmExprOther {} <- expr = fake_pat@@ -1032,14 +1206,14 @@ -- | Generate a fresh `Id` of a given type mkPmId :: Type -> DsM Id mkPmId ty = getUniqueM >>= \unique ->- let occname = mkVarOccFS (fsLit (show unique))+ let occname = mkVarOccFS $ fsLit "$pm" name = mkInternalName unique occname noSrcSpan in return (mkLocalId name ty) -- | Generate a fresh term variable of a given and return it in two forms: -- * A variable pattern -- * A variable expression-mkPmId2Forms :: Type -> DsM (Pattern, LHsExpr Id)+mkPmId2Forms :: Type -> DsM (Pattern, LHsExpr GhcTc) mkPmId2Forms ty = do x <- mkPmId ty return (PmVar x, noLoc (HsVar (noLoc x)))@@ -1089,24 +1263,32 @@ -- These come from two places. -- 1. From data constructors defined with the result type constructor. -- 2. From `COMPLETE` pragmas which have the same type as the result--- type constructor.+-- type constructor. Note that we only use `COMPLETE` pragmas+-- *all* of whose pattern types match. See #14135 allCompleteMatches :: ConLike -> [Type] -> DsM [(Provenance, [ConLike])] allCompleteMatches cl tys = do let fam = case cl of RealDataCon dc -> [(FromBuiltin, map RealDataCon (tyConDataCons (dataConTyCon dc)))] PatSynCon _ -> []-- pragmas <- case splitTyConApp_maybe (conLikeResTy cl tys) of- Just (tc, _) -> dsGetCompleteMatches tc- Nothing -> return []- let fams cm = fmap (FromComplete,) $+ ty = conLikeResTy cl tys+ pragmas <- case splitTyConApp_maybe ty of+ Just (tc, _) -> dsGetCompleteMatches tc+ Nothing -> return []+ let fams cm = (FromComplete,) <$> mapM dsLookupConLike (completeMatchConLikes cm)- from_pragma <- mapM fams pragmas-+ from_pragma <- filter (\(_,m) -> isValidCompleteMatch ty m) <$>+ mapM fams pragmas let final_groups = fam ++ from_pragma- tracePmD "allCompleteMatches" (ppr final_groups) return final_groups+ where+ -- Check that all the pattern types in a `COMPLETE`+ -- pragma subsume the type we're matching. See #14135.+ isValidCompleteMatch :: Type -> [ConLike] -> Bool+ isValidCompleteMatch ty =+ isJust . mapM (flip tcMatchTy ty . resTy . conLikeFullSig)+ where+ resTy (_, _, _, _, _, _, res_ty) = res_ty -- ----------------------------------------------------------------------- -- * Types and constraints@@ -1466,7 +1648,7 @@ force_if False pres = pres set_provenance :: Provenance -> PartialResult -> PartialResult-set_provenance prov pr = pr { presultProvenence = prov }+set_provenance prov pr = pr { presultProvenance = prov } -- ---------------------------------------------------------------------------- -- * Propagation of term constraints inwards when checking nested matches@@ -1506,9 +1688,9 @@ -- When we go deeper to check e.g. e1 we record two equalities: -- (x ~ y), where y is the initial uncovered when checking (p1; .. ; pn) -- and (x ~ p1).-genCaseTmCs2 :: Maybe (LHsExpr Id) -- Scrutinee- -> [Pat Id] -- LHS (should have length 1)- -> [Id] -- MatchVars (should have length 1)+genCaseTmCs2 :: Maybe (LHsExpr GhcTc) -- Scrutinee+ -> [Pat GhcTc] -- LHS (should have length 1)+ -> [Id] -- MatchVars (should have length 1) -> DsM (Bag SimpleEq) genCaseTmCs2 Nothing _ _ = return emptyBag genCaseTmCs2 (Just scr) [p] [var] = do@@ -1522,7 +1704,7 @@ -- case x of { matches } -- When checking matches we record that (x ~ y) where y is the initial -- uncovered. All matches will have to satisfy this equality.-genCaseTmCs1 :: Maybe (LHsExpr Id) -> [Id] -> Bag SimpleEq+genCaseTmCs1 :: Maybe (LHsExpr GhcTc) -> [Id] -> Bag SimpleEq genCaseTmCs1 Nothing _ = emptyBag genCaseTmCs1 (Just scr) [var] = unitBag (var, lhsExprToPmExpr scr) genCaseTmCs1 _ _ = panic "genCaseTmCs1: HsCase"@@ -1736,15 +1918,15 @@ (ppr_match, pref) = case kind of- FunRhs (L _ fun) _ _ -> (pprMatchContext kind,- \ pp -> ppr fun <+> pp)- _ -> (pprMatchContext kind, \ pp -> pp)+ FunRhs { mc_fun = L _ fun }+ -> (pprMatchContext kind, \ pp -> ppr fun <+> pp)+ _ -> (pprMatchContext kind, \ pp -> pp) -ppr_pats :: HsMatchContext Name -> [Pat Id] -> SDoc+ppr_pats :: HsMatchContext Name -> [Pat GhcTc] -> SDoc ppr_pats kind pats = sep [sep (map ppr pats), matchSeparator kind, text "..."] -ppr_eqn :: (SDoc -> SDoc) -> HsMatchContext Name -> [LPat Id] -> SDoc+ppr_eqn :: (SDoc -> SDoc) -> HsMatchContext Name -> [LPat GhcTc] -> SDoc ppr_eqn prefixF kind eqn = prefixF (ppr_pats kind (map unLoc eqn)) ppr_constraint :: (SDoc,[PmLit]) -> SDoc
deSugar/Coverage.hs view
@@ -3,19 +3,17 @@ (c) University of Glasgow, 2007 -} -{-# LANGUAGE CPP, NondecreasingIndentation, RecordWildCards #-}+{-# LANGUAGE NondecreasingIndentation, RecordWildCards #-} module Coverage (addTicksToBinds, hpcInitCode) where +import GhcPrelude as Prelude+ import qualified GHCi import GHCi.RemoteTypes import Data.Array import ByteCodeTypes-#if MIN_VERSION_base(4,9,0) import GHC.Stack.CCS-#else-import GHC.Stack as GHC.Stack.CCS-#endif import Type import HsSyn import Module@@ -68,8 +66,8 @@ -- isExportedId doesn't work yet (the desugarer -- hasn't set it), so we have to work from this set. -> [TyCon] -- Type constructor in this module- -> LHsBinds Id- -> IO (LHsBinds Id, HpcInfo, Maybe ModBreaks)+ -> LHsBinds GhcTc+ -> IO (LHsBinds GhcTc, HpcInfo, Maybe ModBreaks) addTicksToBinds hsc_env mod mod_loc exports tyCons binds | let dflags = hsc_dflags hsc_env@@ -118,7 +116,7 @@ | otherwise = return (binds, emptyHpcInfo False, Nothing) -guessSourceFile :: LHsBinds Id -> FilePath -> FilePath+guessSourceFile :: LHsBinds GhcTc -> FilePath -> FilePath guessSourceFile binds orig_file = -- Try look for a file generated from a .hsc file to a -- .hs file, by peeking ahead.@@ -187,7 +185,7 @@ modTime <- getModificationUTCTime filename let entries' = [ (hpcPos, box) | (span,_,_,box) <- entries, hpcPos <- [mkHpcPos span] ]- when (length entries' /= count) $ do+ when (entries' `lengthIsNot` count) $ do panic "the number of .mix entries are inconsistent" let hashNo = mixHash filename modTime tabStop entries' mixCreate hpc_mod_dir mod_name@@ -252,10 +250,10 @@ -- ----------------------------------------------------------------------------- -- Adding ticks to bindings -addTickLHsBinds :: LHsBinds Id -> TM (LHsBinds Id)+addTickLHsBinds :: LHsBinds GhcTc -> TM (LHsBinds GhcTc) addTickLHsBinds = mapBagM addTickLHsBind -addTickLHsBind :: LHsBind Id -> TM (LHsBind Id)+addTickLHsBind :: LHsBind GhcTc -> TM (LHsBind GhcTc) addTickLHsBind (L pos bind@(AbsBinds { abs_binds = binds, abs_exports = abs_exports })) = do withEnv add_exports $ do@@ -274,35 +272,12 @@ | ABE{ abe_poly = pid, abe_mono = mid } <- abs_exports , idName pid `elemNameSet` (exports env) ] } + -- See Note [inline sccs] add_inlines env = env{ inlines = inlines env `extendVarSetList` [ mid | ABE{ abe_poly = pid, abe_mono = mid } <- abs_exports- , isAnyInlinePragma (idInlinePragma pid) ] }--addTickLHsBind (L pos bind@(AbsBindsSig { abs_sig_bind = val_bind- , abs_sig_export = poly_id }))- | L _ FunBind { fun_id = L _ mono_id } <- val_bind- = do withEnv (add_export mono_id) $ do- withEnv (add_inlines mono_id) $ do- val_bind' <- addTickLHsBind val_bind- return $ L pos $ bind { abs_sig_bind = val_bind' }-- | otherwise- = pprPanic "addTickLHsBind" (ppr bind)- where- -- see AbsBinds comments- add_export mono_id env- | idName poly_id `elemNameSet` exports env- = env { exports = exports env `extendNameSet` idName mono_id }- | otherwise- = env-- add_inlines mono_id env- | isAnyInlinePragma (idInlinePragma poly_id)- = env { inlines = inlines env `extendVarSet` mono_id }- | otherwise- = env+ , isInlinePragma (idInlinePragma pid) ] } addTickLHsBind (L pos (funBind@(FunBind { fun_id = (L _ id) }))) = do let name = getOccString id@@ -310,7 +285,8 @@ density <- getDensity inline_ids <- liftM inlines getEnv- let inline = isAnyInlinePragma (idInlinePragma id)+ -- See Note [inline sccs]+ let inline = isInlinePragma (idInlinePragma id) || id `elemVarSet` inline_ids -- See Note [inline sccs]@@ -394,24 +370,22 @@ -- Note [inline sccs] ----- It should be reasonable to add ticks to INLINE functions; however--- currently this tickles a bug later on because the SCCfinal pass--- does not look inside unfoldings to find CostCentres. It would be--- difficult to fix that, because SCCfinal currently works on STG and--- not Core (and since it also generates CostCentres for CAFs,--- changing this would be difficult too).------ Another reason not to add ticks to INLINE functions is that this+-- The reason not to add ticks to INLINE functions is that this is -- sometimes handy for avoiding adding a tick to a particular function -- (see #6131) -- -- So for now we do not add any ticks to INLINE functions at all.+--+-- We used to use isAnyInlinePragma to figure out whether to avoid adding+-- ticks for this purpose. However, #12962 indicates that this contradicts+-- the documentation on profiling (which only mentions INLINE pragmas).+-- So now we're more careful about what we avoid adding ticks to. -- ----------------------------------------------------------------------------- -- Decorate an LHsExpr with ticks -- selectively add ticks to interesting expressions-addTickLHsExpr :: LHsExpr Id -> TM (LHsExpr Id)+addTickLHsExpr :: LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTickLHsExpr e@(L pos e0) = do d <- getDensity case d of@@ -427,7 +401,7 @@ -- We always consider these to be breakpoints, unless the expression is a 'let' -- (because the body will definitely have a tick somewhere). ToDo: perhaps -- we should treat 'case' and 'if' the same way?-addTickLHsExprRHS :: LHsExpr Id -> TM (LHsExpr Id)+addTickLHsExprRHS :: LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTickLHsExprRHS e@(L pos e0) = do d <- getDensity case d of@@ -444,7 +418,7 @@ -- let binds in [], ( [] ) -- we never tick these if we're doing HPC, but otherwise -- we treat it like an ordinary expression.-addTickLHsExprEvalInner :: LHsExpr Id -> TM (LHsExpr Id)+addTickLHsExprEvalInner :: LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTickLHsExprEvalInner e = do d <- getDensity case d of@@ -456,7 +430,7 @@ -- want to tick the body, even if it is not a redex. See test -- break012. This gives the user the opportunity to inspect the -- values of the let-bound variables.-addTickLHsExprLetBody :: LHsExpr Id -> TM (LHsExpr Id)+addTickLHsExprLetBody :: LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTickLHsExprLetBody e@(L pos e0) = do d <- getDensity case d of@@ -470,32 +444,32 @@ -- version of addTick that does not actually add a tick, -- because the scope of this tick is completely subsumed by -- another.-addTickLHsExprNever :: LHsExpr Id -> TM (LHsExpr Id)+addTickLHsExprNever :: LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTickLHsExprNever (L pos e0) = do e1 <- addTickHsExpr e0 return $ L pos e1 -- general heuristic: expressions which do not denote values are good -- break points-isGoodBreakExpr :: HsExpr Id -> Bool+isGoodBreakExpr :: HsExpr GhcTc -> Bool isGoodBreakExpr (HsApp {}) = True isGoodBreakExpr (HsAppTypeOut {}) = True isGoodBreakExpr (OpApp {}) = True isGoodBreakExpr _other = False -isCallSite :: HsExpr Id -> Bool+isCallSite :: HsExpr GhcTc -> Bool isCallSite HsApp{} = True isCallSite HsAppTypeOut{} = True isCallSite OpApp{} = True isCallSite _ = False -addTickLHsExprOptAlt :: Bool -> LHsExpr Id -> TM (LHsExpr Id)+addTickLHsExprOptAlt :: Bool -> LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTickLHsExprOptAlt oneOfMany (L pos e0) = ifDensity TickForCoverage (allocTickBox (ExpBox oneOfMany) False False pos $ addTickHsExpr e0) (addTickLHsExpr (L pos e0)) -addBinTickLHsExpr :: (Bool -> BoxLabel) -> LHsExpr Id -> TM (LHsExpr Id)+addBinTickLHsExpr :: (Bool -> BoxLabel) -> LHsExpr GhcTc -> TM (LHsExpr GhcTc) addBinTickLHsExpr boxLabel (L pos e0) = ifDensity TickForCoverage (allocBinTickBox boxLabel pos $ addTickHsExpr e0)@@ -507,7 +481,7 @@ -- (Whether to put a tick around the whole expression was already decided, -- in the addTickLHsExpr family of functions.) -addTickHsExpr :: HsExpr Id -> TM (HsExpr Id)+addTickHsExpr :: HsExpr GhcTc -> TM (HsExpr GhcTc) addTickHsExpr e@(HsVar (L _ id)) = do freeVar id; return e addTickHsExpr (HsUnboundVar {}) = panic "addTickHsExpr.HsUnboundVar" addTickHsExpr e@(HsConLikeOut con)@@ -660,24 +634,27 @@ -- Others should never happen in expression content. addTickHsExpr e = pprPanic "addTickHsExpr" (ppr e) -addTickTupArg :: LHsTupArg Id -> TM (LHsTupArg Id)+addTickTupArg :: LHsTupArg GhcTc -> TM (LHsTupArg GhcTc) addTickTupArg (L l (Present e)) = do { e' <- addTickLHsExpr e ; return (L l (Present e')) } addTickTupArg (L l (Missing ty)) = return (L l (Missing ty)) -addTickMatchGroup :: Bool{-is lambda-} -> MatchGroup Id (LHsExpr Id) -> TM (MatchGroup Id (LHsExpr Id))+addTickMatchGroup :: Bool{-is lambda-} -> MatchGroup GhcTc (LHsExpr GhcTc)+ -> TM (MatchGroup GhcTc (LHsExpr GhcTc)) addTickMatchGroup is_lam mg@(MG { mg_alts = L l matches }) = do let isOneOfMany = matchesOneOfMany matches matches' <- mapM (liftL (addTickMatch isOneOfMany is_lam)) matches return $ mg { mg_alts = L l matches' } -addTickMatch :: Bool -> Bool -> Match Id (LHsExpr Id) -> TM (Match Id (LHsExpr Id))-addTickMatch isOneOfMany isLambda (Match mf pats opSig gRHSs) =+addTickMatch :: Bool -> Bool -> Match GhcTc (LHsExpr GhcTc)+ -> TM (Match GhcTc (LHsExpr GhcTc))+addTickMatch isOneOfMany isLambda match@(Match { m_pats = pats, m_grhss = gRHSs }) = bindLocals (collectPatsBinders pats) $ do gRHSs' <- addTickGRHSs isOneOfMany isLambda gRHSs- return $ Match mf pats opSig gRHSs'+ return $ match { m_grhss = gRHSs' } -addTickGRHSs :: Bool -> Bool -> GRHSs Id (LHsExpr Id) -> TM (GRHSs Id (LHsExpr Id))+addTickGRHSs :: Bool -> Bool -> GRHSs GhcTc (LHsExpr GhcTc)+ -> TM (GRHSs GhcTc (LHsExpr GhcTc)) addTickGRHSs isOneOfMany isLambda (GRHSs guarded (L l local_binds)) = do bindLocals binders $ do local_binds' <- addTickHsLocalBinds local_binds@@ -686,13 +663,14 @@ where binders = collectLocalBinders local_binds -addTickGRHS :: Bool -> Bool -> GRHS Id (LHsExpr Id) -> TM (GRHS Id (LHsExpr Id))+addTickGRHS :: Bool -> Bool -> GRHS GhcTc (LHsExpr GhcTc)+ -> TM (GRHS GhcTc (LHsExpr GhcTc)) addTickGRHS isOneOfMany isLambda (GRHS stmts expr) = do (stmts',expr') <- addTickLStmts' (Just $ BinBox $ GuardBinBox) stmts (addTickGRHSBody isOneOfMany isLambda expr) return $ GRHS stmts' expr' -addTickGRHSBody :: Bool -> Bool -> LHsExpr Id -> TM (LHsExpr Id)+addTickGRHSBody :: Bool -> Bool -> LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTickGRHSBody isOneOfMany isLambda expr@(L pos e0) = do d <- getDensity case d of@@ -704,20 +682,22 @@ _otherwise -> addTickLHsExprRHS expr -addTickLStmts :: (Maybe (Bool -> BoxLabel)) -> [ExprLStmt Id] -> TM [ExprLStmt Id]+addTickLStmts :: (Maybe (Bool -> BoxLabel)) -> [ExprLStmt GhcTc]+ -> TM [ExprLStmt GhcTc] addTickLStmts isGuard stmts = do (stmts, _) <- addTickLStmts' isGuard stmts (return ()) return stmts -addTickLStmts' :: (Maybe (Bool -> BoxLabel)) -> [ExprLStmt Id] -> TM a- -> TM ([ExprLStmt Id], a)+addTickLStmts' :: (Maybe (Bool -> BoxLabel)) -> [ExprLStmt GhcTc] -> TM a+ -> TM ([ExprLStmt GhcTc], a) addTickLStmts' isGuard lstmts res = bindLocals (collectLStmtsBinders lstmts) $ do { lstmts' <- mapM (liftL (addTickStmt isGuard)) lstmts ; a <- res ; return (lstmts', a) } -addTickStmt :: (Maybe (Bool -> BoxLabel)) -> Stmt Id (LHsExpr Id) -> TM (Stmt Id (LHsExpr Id))+addTickStmt :: (Maybe (Bool -> BoxLabel)) -> Stmt GhcTc (LHsExpr GhcTc)+ -> TM (Stmt GhcTc (LHsExpr GhcTc)) addTickStmt _isGuard (LastStmt e noret ret) = do liftM3 LastStmt (addTickLHsExpr e)@@ -770,33 +750,36 @@ ; return (stmt { recS_stmts = stmts', recS_ret_fn = ret' , recS_mfix_fn = mfix', recS_bind_fn = bind' }) } -addTick :: Maybe (Bool -> BoxLabel) -> LHsExpr Id -> TM (LHsExpr Id)+addTick :: Maybe (Bool -> BoxLabel) -> LHsExpr GhcTc -> TM (LHsExpr GhcTc) addTick isGuard e | Just fn <- isGuard = addBinTickLHsExpr fn e | otherwise = addTickLHsExprRHS e addTickApplicativeArg- :: Maybe (Bool -> BoxLabel) -> (SyntaxExpr Id, ApplicativeArg Id Id)- -> TM (SyntaxExpr Id, ApplicativeArg Id Id)+ :: Maybe (Bool -> BoxLabel) -> (SyntaxExpr GhcTc, ApplicativeArg GhcTc GhcTc)+ -> TM (SyntaxExpr GhcTc, ApplicativeArg GhcTc GhcTc) addTickApplicativeArg isGuard (op, arg) = liftM2 (,) (addTickSyntaxExpr hpcSrcSpan op) (addTickArg arg) where- addTickArg (ApplicativeArgOne pat expr) =- ApplicativeArgOne <$> addTickLPat pat <*> addTickLHsExpr expr+ addTickArg (ApplicativeArgOne pat expr isBody) =+ ApplicativeArgOne+ <$> addTickLPat pat+ <*> addTickLHsExpr expr+ <*> pure isBody addTickArg (ApplicativeArgMany stmts ret pat) = ApplicativeArgMany <$> addTickLStmts isGuard stmts <*> (unLoc <$> addTickLHsExpr (L hpcSrcSpan ret)) <*> addTickLPat pat -addTickStmtAndBinders :: Maybe (Bool -> BoxLabel) -> ParStmtBlock Id Id- -> TM (ParStmtBlock Id Id)+addTickStmtAndBinders :: Maybe (Bool -> BoxLabel) -> ParStmtBlock GhcTc GhcTc+ -> TM (ParStmtBlock GhcTc GhcTc) addTickStmtAndBinders isGuard (ParStmtBlock stmts ids returnExpr) = liftM3 ParStmtBlock (addTickLStmts isGuard stmts) (return ids) (addTickSyntaxExpr hpcSrcSpan returnExpr) -addTickHsLocalBinds :: HsLocalBinds Id -> TM (HsLocalBinds Id)+addTickHsLocalBinds :: HsLocalBinds GhcTc -> TM (HsLocalBinds GhcTc) addTickHsLocalBinds (HsValBinds binds) = liftM HsValBinds (addTickHsValBinds binds)@@ -805,7 +788,7 @@ (addTickHsIPBinds binds) addTickHsLocalBinds (EmptyLocalBinds) = return EmptyLocalBinds -addTickHsValBinds :: HsValBindsLR Id a -> TM (HsValBindsLR Id b)+addTickHsValBinds :: HsValBindsLR GhcTc a -> TM (HsValBindsLR GhcTc b) addTickHsValBinds (ValBindsOut binds sigs) = liftM2 ValBindsOut (mapM (\ (rec,binds') ->@@ -816,28 +799,28 @@ (return sigs) addTickHsValBinds _ = panic "addTickHsValBinds" -addTickHsIPBinds :: HsIPBinds Id -> TM (HsIPBinds Id)+addTickHsIPBinds :: HsIPBinds GhcTc -> TM (HsIPBinds GhcTc) addTickHsIPBinds (IPBinds ipbinds dictbinds) = liftM2 IPBinds (mapM (liftL (addTickIPBind)) ipbinds) (return dictbinds) -addTickIPBind :: IPBind Id -> TM (IPBind Id)+addTickIPBind :: IPBind GhcTc -> TM (IPBind GhcTc) addTickIPBind (IPBind nm e) = liftM2 IPBind (return nm) (addTickLHsExpr e) -- There is no location here, so we might need to use a context location??-addTickSyntaxExpr :: SrcSpan -> SyntaxExpr Id -> TM (SyntaxExpr Id)+addTickSyntaxExpr :: SrcSpan -> SyntaxExpr GhcTc -> TM (SyntaxExpr GhcTc) addTickSyntaxExpr pos syn@(SyntaxExpr { syn_expr = x }) = do L _ x' <- addTickLHsExpr (L pos x) return $ syn { syn_expr = x' } -- we do not walk into patterns.-addTickLPat :: LPat Id -> TM (LPat Id)+addTickLPat :: LPat GhcTc -> TM (LPat GhcTc) addTickLPat pat = return pat -addTickHsCmdTop :: HsCmdTop Id -> TM (HsCmdTop Id)+addTickHsCmdTop :: HsCmdTop GhcTc -> TM (HsCmdTop GhcTc) addTickHsCmdTop (HsCmdTop cmd tys ty syntaxtable) = liftM4 HsCmdTop (addTickLHsCmd cmd)@@ -845,12 +828,12 @@ (return ty) (return syntaxtable) -addTickLHsCmd :: LHsCmd Id -> TM (LHsCmd Id)+addTickLHsCmd :: LHsCmd GhcTc -> TM (LHsCmd GhcTc) addTickLHsCmd (L pos c0) = do c1 <- addTickHsCmd c0 return $ L pos c1 -addTickHsCmd :: HsCmd Id -> TM (HsCmd Id)+addTickHsCmd :: HsCmd GhcTc -> TM (HsCmd GhcTc) addTickHsCmd (HsCmdLam matchgroup) = liftM HsCmdLam (addTickCmdMatchGroup matchgroup) addTickHsCmd (HsCmdApp c e) =@@ -902,18 +885,19 @@ -- Others should never happen in a command context. --addTickHsCmd e = pprPanic "addTickHsCmd" (ppr e) -addTickCmdMatchGroup :: MatchGroup Id (LHsCmd Id) -> TM (MatchGroup Id (LHsCmd Id))+addTickCmdMatchGroup :: MatchGroup GhcTc (LHsCmd GhcTc)+ -> TM (MatchGroup GhcTc (LHsCmd GhcTc)) addTickCmdMatchGroup mg@(MG { mg_alts = L l matches }) = do matches' <- mapM (liftL addTickCmdMatch) matches return $ mg { mg_alts = L l matches' } -addTickCmdMatch :: Match Id (LHsCmd Id) -> TM (Match Id (LHsCmd Id))-addTickCmdMatch (Match mf pats opSig gRHSs) =+addTickCmdMatch :: Match GhcTc (LHsCmd GhcTc) -> TM (Match GhcTc (LHsCmd GhcTc))+addTickCmdMatch match@(Match { m_pats = pats, m_grhss = gRHSs }) = bindLocals (collectPatsBinders pats) $ do gRHSs' <- addTickCmdGRHSs gRHSs- return $ Match mf pats opSig gRHSs'+ return $ match { m_grhss = gRHSs' } -addTickCmdGRHSs :: GRHSs Id (LHsCmd Id) -> TM (GRHSs Id (LHsCmd Id))+addTickCmdGRHSs :: GRHSs GhcTc (LHsCmd GhcTc) -> TM (GRHSs GhcTc (LHsCmd GhcTc)) addTickCmdGRHSs (GRHSs guarded (L l local_binds)) = do bindLocals binders $ do local_binds' <- addTickHsLocalBinds local_binds@@ -922,7 +906,7 @@ where binders = collectLocalBinders local_binds -addTickCmdGRHS :: GRHS Id (LHsCmd Id) -> TM (GRHS Id (LHsCmd Id))+addTickCmdGRHS :: GRHS GhcTc (LHsCmd GhcTc) -> TM (GRHS GhcTc (LHsCmd GhcTc)) -- The *guards* are *not* Cmds, although the body is -- C.f. addTickGRHS for the BinBox stuff addTickCmdGRHS (GRHS stmts cmd)@@ -930,12 +914,14 @@ stmts (addTickLHsCmd cmd) ; return $ GRHS stmts' expr' } -addTickLCmdStmts :: [LStmt Id (LHsCmd Id)] -> TM [LStmt Id (LHsCmd Id)]+addTickLCmdStmts :: [LStmt GhcTc (LHsCmd GhcTc)]+ -> TM [LStmt GhcTc (LHsCmd GhcTc)] addTickLCmdStmts stmts = do (stmts, _) <- addTickLCmdStmts' stmts (return ()) return stmts -addTickLCmdStmts' :: [LStmt Id (LHsCmd Id)] -> TM a -> TM ([LStmt Id (LHsCmd Id)], a)+addTickLCmdStmts' :: [LStmt GhcTc (LHsCmd GhcTc)] -> TM a+ -> TM ([LStmt GhcTc (LHsCmd GhcTc)], a) addTickLCmdStmts' lstmts res = bindLocals binders $ do lstmts' <- mapM (liftL addTickCmdStmt) lstmts@@ -944,7 +930,7 @@ where binders = collectLStmtsBinders lstmts -addTickCmdStmt :: Stmt Id (LHsCmd Id) -> TM (Stmt Id (LHsCmd Id))+addTickCmdStmt :: Stmt GhcTc (LHsCmd GhcTc) -> TM (Stmt GhcTc (LHsCmd GhcTc)) addTickCmdStmt (BindStmt pat c bind fail ty) = do liftM5 BindStmt (addTickLPat pat)@@ -979,18 +965,19 @@ -- Others should never happen in a command context. addTickCmdStmt stmt = pprPanic "addTickHsCmd" (ppr stmt) -addTickHsRecordBinds :: HsRecordBinds Id -> TM (HsRecordBinds Id)+addTickHsRecordBinds :: HsRecordBinds GhcTc -> TM (HsRecordBinds GhcTc) addTickHsRecordBinds (HsRecFields fields dd) = do { fields' <- mapM addTickHsRecField fields ; return (HsRecFields fields' dd) } -addTickHsRecField :: LHsRecField' id (LHsExpr Id) -> TM (LHsRecField' id (LHsExpr Id))+addTickHsRecField :: LHsRecField' id (LHsExpr GhcTc)+ -> TM (LHsRecField' id (LHsExpr GhcTc)) addTickHsRecField (L l (HsRecField id expr pun)) = do { expr' <- addTickLHsExpr expr ; return (L l (HsRecField id expr' pun)) } -addTickArithSeqInfo :: ArithSeqInfo Id -> TM (ArithSeqInfo Id)+addTickArithSeqInfo :: ArithSeqInfo GhcTc -> TM (ArithSeqInfo GhcTc) addTickArithSeqInfo (From e1) = liftM From (addTickLHsExpr e1)@@ -1166,8 +1153,8 @@ -- the tick application inherits the source position of its -- expression argument to support nested box allocations-allocTickBox :: BoxLabel -> Bool -> Bool -> SrcSpan -> TM (HsExpr Id)- -> TM (LHsExpr Id)+allocTickBox :: BoxLabel -> Bool -> Bool -> SrcSpan -> TM (HsExpr GhcTc)+ -> TM (LHsExpr GhcTc) allocTickBox boxLabel countEntries topOnly pos m = ifGoodTickSrcSpan pos (do (fvs, e) <- getFreeVars m@@ -1238,8 +1225,8 @@ _otherwise -> panic "mkTickish: bad source span!" -allocBinTickBox :: (Bool -> BoxLabel) -> SrcSpan -> TM (HsExpr Id)- -> TM (LHsExpr Id)+allocBinTickBox :: (Bool -> BoxLabel) -> SrcSpan -> TM (HsExpr GhcTc)+ -> TM (LHsExpr GhcTc) allocBinTickBox boxLabel pos m = do env <- getEnv case tickishType env of@@ -1249,8 +1236,8 @@ (return e) _other -> allocTickBox (ExpBox False) False False pos m -mkBinTickBoxHpc :: (Bool -> BoxLabel) -> SrcSpan -> LHsExpr Id- -> TM (LHsExpr Id)+mkBinTickBoxHpc :: (Bool -> BoxLabel) -> SrcSpan -> LHsExpr GhcTc+ -> TM (LHsExpr GhcTc) mkBinTickBoxHpc boxLabel pos e = TM $ \ env st -> let meT = (pos,declPath env, [],boxLabel True)@@ -1283,10 +1270,10 @@ hpcSrcSpan :: SrcSpan hpcSrcSpan = mkGeneralSrcSpan (fsLit "Haskell Program Coverage internals") -matchesOneOfMany :: [LMatch Id body] -> Bool+matchesOneOfMany :: [LMatch GhcTc body] -> Bool matchesOneOfMany lmatches = sum (map matchCount lmatches) > 1 where- matchCount (L _ (Match _ _pats _ty (GRHSs grhss _binds))) = length grhss+ matchCount (L _ (Match { m_grhss = GRHSs grhss _binds })) = length grhss type MixEntry_ = (SrcSpan, [String], [OccName], BoxLabel)
deSugar/Desugar.hs view
@@ -7,6 +7,7 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module Desugar ( -- * Desugaring operations@@ -15,6 +16,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DsUsage import DynFlags import HscTypes@@ -147,7 +150,8 @@ keep_alive <- readIORef keep_var ; let (rules_for_locals, rules_for_imps) = partition isLocalRule all_rules final_prs = addExportFlagsAndRules target export_set keep_alive- rules_for_locals (fromOL all_prs)+ mod rules_for_locals+ (fromOL all_prs) final_pgm = combineEvBinds ds_ev_binds final_prs -- Notice that we put the whole lot in a big Rec, even the foreign binds@@ -156,7 +160,7 @@ -- You might think it doesn't matter, but the simplifier brings all top-level -- things into the in-scope set before simplifying; so we get no unfolding for F#! -#ifdef DEBUG+#if defined(DEBUG) -- Debug only as pre-simple-optimisation program may be really big ; endPassIO hsc_env print_unqual CoreDesugar final_pgm rules_for_imps #endif@@ -250,7 +254,7 @@ and Rec the rest. -} -deSugarExpr :: HscEnv -> LHsExpr Id -> IO (Messages, Maybe CoreExpr)+deSugarExpr :: HscEnv -> LHsExpr GhcTc -> IO (Messages, Maybe CoreExpr) deSugarExpr hsc_env tc_expr = do { let dflags = hsc_dflags hsc_env@@ -277,9 +281,9 @@ -} addExportFlagsAndRules- :: HscTarget -> NameSet -> NameSet -> [CoreRule]+ :: HscTarget -> NameSet -> NameSet -> Module -> [CoreRule] -> [(Id, t)] -> [(Id, t)]-addExportFlagsAndRules target exports keep_alive rules prs+addExportFlagsAndRules target exports keep_alive mod rules prs = mapFst add_one prs where add_one bndr = add_rules name (add_export name bndr)@@ -312,10 +316,20 @@ -- simplification), and retain them all in the TypeEnv so they are -- available from the command line. --+ -- Most of the time, this can be accomplished by use of+ -- targetRetainsAllBindings, which returns True if the target is+ -- HscInteractive. However, there are cases when one can use GHCi with+ -- a target other than HscInteractive (e.g., with the -fobject-code+ -- flag enabled, as in #12091). In such scenarios,+ -- targetRetainsAllBindings can return False, so we must fall back on+ -- isInteractiveModule to be doubly sure we export entities defined in+ -- a GHCi session.+ -- -- isExternalName separates the user-defined top-level names from those -- introduced by the type checker. is_exported :: Name -> Bool- is_exported | targetRetainsAllBindings target = isExternalName+ is_exported | targetRetainsAllBindings target+ || isInteractiveModule mod = isExternalName | otherwise = (`elemNameSet` exports) {-@@ -362,7 +376,7 @@ ************************************************************************ -} -dsRule :: LRuleDecl Id -> DsM (Maybe CoreRule)+dsRule :: LRuleDecl GhcTc -> DsM (Maybe CoreRule) dsRule (L loc (HsRule name rule_act vars lhs _tv_lhs rhs _fv_rhs)) = putSrcSpanDs loc $ do { let bndrs' = [var | L _ (RuleBndr (L _ var)) <- vars]@@ -423,7 +437,7 @@ <+> text "might inline first") , text "Probable fix: add an INLINE[n] or NOINLINE[n] pragma for" <+> quotes (ppr lhs_id)- , ifPprDebug (ppr (idInlineActivation lhs_id) $$ ppr rule_act) ])+ , whenPprDebug (ppr (idInlineActivation lhs_id) $$ ppr rule_act) ]) | check_rules_too , bad_rule : _ <- get_bad_rules lhs_id@@ -434,7 +448,7 @@ <+> text "for"<+> quotes (ppr lhs_id) <+> text "might fire first") , text "Probable fix: add phase [n] or [~n] to the competing rule"- , ifPprDebug (ppr bad_rule) ])+ , whenPprDebug (ppr bad_rule) ]) | otherwise = return ()@@ -541,7 +555,7 @@ ************************************************************************ -} -dsVect :: LVectDecl Id -> DsM CoreVect+dsVect :: LVectDecl GhcTc -> DsM CoreVect dsVect (L loc (HsVect _ (L _ v) rhs)) = putSrcSpanDs loc $ do { rhs' <- dsLExpr rhs
deSugar/DsArrows.hs view
@@ -7,11 +7,14 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module DsArrows ( dsProcExpr ) where #include "HsVersions.h" +import GhcPrelude+ import Match import DsUtils import DsMonad@@ -37,7 +40,6 @@ import DsBinds (dsHsWrapper) import Name-import Var import Id import ConLike import TysWiredIn@@ -57,7 +59,7 @@ arr_id, compose_id, first_id, app_id, choice_id, loop_id :: CoreExpr } -mkCmdEnv :: CmdSyntaxTable Id -> DsM ([CoreBind], DsCmdEnv)+mkCmdEnv :: CmdSyntaxTable GhcTc -> DsM ([CoreBind], DsCmdEnv) -- See Note [CmdSyntaxTable] in HsExpr mkCmdEnv tc_meths = do { (meth_binds, prs) <- mapAndUnzipM mk_bind tc_meths@@ -295,7 +297,7 @@ pair_id <- newSysLocalDs (mkCorePairTy (idType param_id) (idType tail_id)) return (pair_id, coreCasePair pair_id param_id tail_id tail_code) -mkHsEnvStackExpr :: [Id] -> Id -> LHsExpr Id+mkHsEnvStackExpr :: [Id] -> Id -> LHsExpr GhcTc mkHsEnvStackExpr env_ids stack_id = mkLHsTupleExpr [mkLHsVarTuple env_ids, nlHsVar stack_id] @@ -308,8 +310,8 @@ -- where (xs) is the tuple of variables bound by p dsProcExpr- :: LPat Id- -> LHsCmdTop Id+ :: LPat GhcTc+ -> LHsCmdTop GhcTc -> DsM CoreExpr dsProcExpr pat (L _ (HsCmdTop cmd _unitTy cmd_ty ids)) = do (meth_binds, meth_ids) <- mkCmdEnv ids@@ -337,7 +339,7 @@ D |- e :: a (xs, stk) t -} -dsLCmd :: DsCmdEnv -> IdSet -> Type -> Type -> LHsCmd Id -> [Id]+dsLCmd :: DsCmdEnv -> IdSet -> Type -> Type -> LHsCmd GhcTc -> [Id] -> DsM (CoreExpr, DIdSet) dsLCmd ids local_vars stk_ty res_ty cmd env_ids = dsCmd ids local_vars stk_ty res_ty (unLoc cmd) env_ids@@ -346,8 +348,8 @@ -> IdSet -- set of local vars available to this command -> Type -- type of the stack (right-nested tuple) -> Type -- return type of the command- -> HsCmd Id -- command to desugar- -> [Id] -- list of vars in the input to this command+ -> HsCmd GhcTc -- command to desugar+ -> [Id] -- list of vars in the input to this command -- This is typically fed back, -- so don't pull on it too early -> DsM (CoreExpr, -- desugared expression@@ -447,8 +449,8 @@ -- ---> premap (\ ((xs), (p1, ... (pk,stk)...)) -> ((ys),stk)) cmd dsCmd ids local_vars stack_ty res_ty- (HsCmdLam (MG { mg_alts = L _ [L _ (Match _ pats _- (GRHSs [L _ (GRHS [] body)] _ ))] }))+ (HsCmdLam (MG { mg_alts = L _ [L _ (Match { m_pats = pats+ , m_grhss = GRHSs [L _ (GRHS [] body)] _ })] })) env_ids = do let pat_vars = mkVarSet (collectPatsBinders pats) let@@ -575,8 +577,8 @@ let left_id = HsConLikeOut (RealDataCon left_con) right_id = HsConLikeOut (RealDataCon right_con)- left_expr ty1 ty2 e = noLoc $ HsApp (noLoc $ HsWrap (mkWpTyApps [ty1, ty2]) left_id ) e- right_expr ty1 ty2 e = noLoc $ HsApp (noLoc $ HsWrap (mkWpTyApps [ty1, ty2]) right_id) e+ left_expr ty1 ty2 e = noLoc $ HsApp (noLoc $ mkHsWrap (mkWpTyApps [ty1, ty2]) left_id ) e+ right_expr ty1 ty2 e = noLoc $ HsApp (noLoc $ mkHsWrap (mkWpTyApps [ty1, ty2]) right_id) e -- Prefix each tuple with a distinct series of Left's and Right's, -- in a balanced way, keeping track of the types.@@ -676,8 +678,8 @@ dsTrimCmdArg :: IdSet -- set of local vars available to this command- -> [Id] -- list of vars in the input to this command- -> LHsCmdTop Id -- command argument to desugar+ -> [Id] -- list of vars in the input to this command+ -> LHsCmdTop GhcTc -- command argument to desugar -> DsM (CoreExpr, -- desugared expression DIdSet) -- subset of local vars that occur free dsTrimCmdArg local_vars env_ids (L _ (HsCmdTop cmd stack_ty cmd_ty ids)) = do@@ -700,7 +702,7 @@ -> IdSet -- set of local vars available to this command -> Type -- type of the stack (right-nested tuple) -> Type -- return type of the command- -> LHsCmd Id -- command to desugar+ -> LHsCmd GhcTc -- command to desugar -> DsM (CoreExpr, -- desugared expression DIdSet, -- subset of local vars that occur free [Id]) -- the same local vars as a list, fed back@@ -733,7 +735,7 @@ dsCmdDo :: DsCmdEnv -- arrow combinators -> IdSet -- set of local vars available to this statement -> Type -- return type of the statement- -> [CmdLStmt Id] -- statements to desugar+ -> [CmdLStmt GhcTc] -- statements to desugar -> [Id] -- list of vars in the input to this statement -- This is typically fed back, -- so don't pull on it too early@@ -782,7 +784,7 @@ translated to a composition of such arrows. -} -dsCmdLStmt :: DsCmdEnv -> IdSet -> [Id] -> CmdLStmt Id -> [Id]+dsCmdLStmt :: DsCmdEnv -> IdSet -> [Id] -> CmdLStmt GhcTc -> [Id] -> DsM (CoreExpr, DIdSet) dsCmdLStmt ids local_vars out_ids cmd env_ids = dsCmdStmt ids local_vars out_ids (unLoc cmd) env_ids@@ -791,7 +793,7 @@ :: DsCmdEnv -- arrow combinators -> IdSet -- set of local vars available to this statement -> [Id] -- list of vars in the output of this statement- -> CmdStmt Id -- statement to desugar+ -> CmdStmt GhcTc -- statement to desugar -> [Id] -- list of vars in the input to this statement -- This is typically fed back, -- so don't pull on it too early@@ -973,11 +975,11 @@ dsRecCmd :: DsCmdEnv -- arrow combinators -> IdSet -- set of local vars available to this statement- -> [CmdLStmt Id] -- list of statements inside the RecCmd+ -> [CmdLStmt GhcTc] -- list of statements inside the RecCmd -> [Id] -- list of vars defined here and used later- -> [HsExpr Id] -- expressions corresponding to later_ids+ -> [HsExpr GhcTc] -- expressions corresponding to later_ids -> [Id] -- list of vars fed back through the loop- -> [HsExpr Id] -- expressions corresponding to rec_ids+ -> [HsExpr GhcTc] -- expressions corresponding to rec_ids -> DsM (CoreExpr, -- desugared statement DIdSet, -- subset of local vars that occur free [Id]) -- same local vars as a list@@ -1051,7 +1053,7 @@ :: DsCmdEnv -- arrow combinators -> IdSet -- set of local vars available to this statement -> [Id] -- output vars of these statements- -> [CmdLStmt Id] -- statements to desugar+ -> [CmdLStmt GhcTc] -- statements to desugar -> DsM (CoreExpr, -- desugared expression DIdSet, -- subset of local vars that occur free [Id]) -- same local vars as a list@@ -1065,7 +1067,7 @@ :: DsCmdEnv -- arrow combinators -> IdSet -- set of local vars available to this statement -> [Id] -- output vars of these statements- -> [CmdLStmt Id] -- statements to desugar+ -> [CmdLStmt GhcTc] -- statements to desugar -> [Id] -- list of vars in the input to these statements -> DsM (CoreExpr, -- desugared expression DIdSet) -- subset of local vars that occur free@@ -1092,7 +1094,7 @@ matchSimplys :: [CoreExpr] -- Scrutinees -> HsMatchContext Name -- Match kind- -> [LPat Id] -- Patterns they should match+ -> [LPat GhcTc] -- Patterns they should match -> CoreExpr -- Return this if they all match -> CoreExpr -- Return this if they don't -> DsM CoreExpr@@ -1104,8 +1106,9 @@ -- List of leaf expressions, with set of variables bound in each -leavesMatch :: LMatch Id (Located (body Id)) -> [(Located (body Id), IdSet)]-leavesMatch (L _ (Match _ pats _ (GRHSs grhss (L _ binds))))+leavesMatch :: LMatch GhcTc (Located (body GhcTc))+ -> [(Located (body GhcTc), IdSet)]+leavesMatch (L _ (Match { m_pats = pats, m_grhss = GRHSs grhss (L _ binds) })) = let defined_vars = mkVarSet (collectPatsBinders pats) `unionVarSet`@@ -1120,21 +1123,21 @@ replaceLeavesMatch :: Type -- new result type- -> [Located (body' Id)] -- replacement leaf expressions of that type- -> LMatch Id (Located (body Id)) -- the matches of a case command- -> ([Located (body' Id)], -- remaining leaf expressions- LMatch Id (Located (body' Id))) -- updated match-replaceLeavesMatch _res_ty leaves (L loc (Match mf pat mt (GRHSs grhss binds)))+ -> [Located (body' GhcTc)] -- replacement leaf expressions of that type+ -> LMatch GhcTc (Located (body GhcTc)) -- the matches of a case command+ -> ([Located (body' GhcTc)], -- remaining leaf expressions+ LMatch GhcTc (Located (body' GhcTc))) -- updated match+replaceLeavesMatch _res_ty leaves (L loc match@(Match { m_grhss = GRHSs grhss binds })) = let (leaves', grhss') = mapAccumL replaceLeavesGRHS leaves grhss in- (leaves', L loc (Match mf pat mt (GRHSs grhss' binds)))+ (leaves', L loc (match { m_grhss = GRHSs grhss' binds })) replaceLeavesGRHS- :: [Located (body' Id)] -- replacement leaf expressions of that type- -> LGRHS Id (Located (body Id)) -- rhss of a case command- -> ([Located (body' Id)], -- remaining leaf expressions- LGRHS Id (Located (body' Id))) -- updated GRHS+ :: [Located (body' GhcTc)] -- replacement leaf expressions of that type+ -> LGRHS GhcTc (Located (body GhcTc)) -- rhss of a case command+ -> ([Located (body' GhcTc)], -- remaining leaf expressions+ LGRHS GhcTc (Located (body' GhcTc))) -- updated GRHS replaceLeavesGRHS (leaf:leaves) (L loc (GRHS stmts _)) = (leaves, L loc (GRHS stmts leaf)) replaceLeavesGRHS [] _ = panic "replaceLeavesGRHS []"@@ -1172,14 +1175,14 @@ these bindings. -} -collectPatBinders :: LPat Id -> [Id]+collectPatBinders :: LPat GhcTc -> [Id] collectPatBinders pat = collectl pat [] -collectPatsBinders :: [LPat Id] -> [Id]+collectPatsBinders :: [LPat GhcTc] -> [Id] collectPatsBinders pats = foldr collectl [] pats ----------------------collectl :: LPat Id -> [Id] -> [Id]+collectl :: LPat GhcTc -> [Id] -> [Id] -- See Note [Dictionary binders in ConPatOut] collectl (L _ pat) bndrs = go pat@@ -1219,12 +1222,12 @@ | otherwise = bs -- A worry: what about coercion variable binders?? -collectLStmtsBinders :: [LStmt Id body] -> [Id]+collectLStmtsBinders :: [LStmt GhcTc body] -> [Id] collectLStmtsBinders = concatMap collectLStmtBinders -collectLStmtBinders :: LStmt Id body -> [Id]+collectLStmtBinders :: LStmt GhcTc body -> [Id] collectLStmtBinders = collectStmtBinders . unLoc -collectStmtBinders :: Stmt Id body -> [Id]+collectStmtBinders :: Stmt GhcTc body -> [Id] collectStmtBinders (RecStmt { recS_later_ids = later_ids }) = later_ids collectStmtBinders stmt = HsUtils.collectStmtBinders stmt
deSugar/DsBinds.hs view
@@ -11,6 +11,7 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module DsBinds ( dsTopLHsBinds, dsLHsBinds, decomposeRuleLhs, dsSpec, dsHsWrapper, dsTcEvBinds, dsTcEvBinds_s, dsEvBinds, dsMkUserRule@@ -18,6 +19,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} DsExpr( dsLExpr ) import {-# SOURCE #-} Match( matchWrapper ) @@ -51,6 +54,7 @@ import VarSet import Rules import VarEnv+import Var( EvVar ) import Outputable import Module import SrcLoc@@ -73,12 +77,12 @@ -- | Desugar top level binds, strict binds are treated like normal -- binds since there is no good time to force before first usage.-dsTopLHsBinds :: LHsBinds Id -> DsM (OrdList (Id,CoreExpr))+dsTopLHsBinds :: LHsBinds GhcTc -> DsM (OrdList (Id,CoreExpr)) dsTopLHsBinds binds -- see Note [Strict binds checks] | not (isEmptyBag unlifted_binds) || not (isEmptyBag bang_binds) = do { mapBagM_ (top_level_err "bindings for unlifted types") unlifted_binds- ; mapBagM_ (top_level_err "strict pattern bindings") bang_binds+ ; mapBagM_ (top_level_err "strict bindings") bang_binds ; return nilOL } | otherwise@@ -92,7 +96,7 @@ where unlifted_binds = filterBag (isUnliftedHsBind . unLoc) binds- bang_binds = filterBag (isBangedPatBind . unLoc) binds+ bang_binds = filterBag (isBangedHsBind . unLoc) binds top_level_err desc (L loc bind) = putSrcSpanDs loc $@@ -102,31 +106,29 @@ -- | Desugar all other kind of bindings, Ids of strict binds are returned to -- later be forced in the binding group body, see Note [Desugar Strict binds]-dsLHsBinds :: LHsBinds Id -> DsM ([Id], [(Id,CoreExpr)])+dsLHsBinds :: LHsBinds GhcTc -> DsM ([Id], [(Id,CoreExpr)]) dsLHsBinds binds- = do { MASSERT( allBag (not . isUnliftedHsBind . unLoc) binds )- ; ds_bs <- mapBagM dsLHsBind binds+ = do { ds_bs <- mapBagM dsLHsBind binds ; return (foldBag (\(a, a') (b, b') -> (a ++ b, a' ++ b')) id ([], []) ds_bs) } -------------------------dsLHsBind :: LHsBind Id+dsLHsBind :: LHsBind GhcTc -> DsM ([Id], [(Id,CoreExpr)]) dsLHsBind (L loc bind) = do dflags <- getDynFlags putSrcSpanDs loc $ dsHsBind dflags bind -- | Desugar a single binding (or group of recursive binds). dsHsBind :: DynFlags- -> HsBind Id+ -> HsBind GhcTc -> DsM ([Id], [(Id,CoreExpr)]) -- ^ The Ids of strict binds, to be forced in the body of the -- binding group see Note [Desugar Strict binds] and all -- bindings and their desugared right hand sides. -dsHsBind dflags- (VarBind { var_id = var- , var_rhs = expr- , var_inline = inline_regardless })+dsHsBind dflags (VarBind { var_id = var+ , var_rhs = expr+ , var_inline = inline_regardless }) = do { core_expr <- dsLExpr expr -- Dictionary bindings are always VarBinds, -- so we only need do this here@@ -138,9 +140,8 @@ else [] ; return (force_var, [core_bind]) } -dsHsBind dflags- b@(FunBind { fun_id = L _ fun, fun_matches = matches- , fun_co_fn = co_fn, fun_tick = tick })+dsHsBind dflags b@(FunBind { fun_id = L _ fun, fun_matches = matches+ , fun_co_fn = co_fn, fun_tick = tick }) = do { (args, body) <- matchWrapper (mkPrefixFunRhs (noLoc $ idName fun)) Nothing matches@@ -153,16 +154,18 @@ | xopt LangExt.Strict dflags , matchGroupArity matches == 0 -- no need to force lambdas = [id]- | isBangedBind b+ | isBangedHsBind b = [id] | otherwise = []- ; --pprTrace "dsHsBind" (ppr fun <+> ppr (idInlinePragma fun) $$ ppr (mg_alts matches) $$ ppr args $$ ppr core_binds) $- return (force_var, [core_binds]) }+ ; --pprTrace "dsHsBind" (vcat [ ppr fun <+> ppr (idInlinePragma fun)+ -- , ppr (mg_alts matches)+ -- , ppr args, ppr core_binds]) $+ return (force_var, [core_binds]) } -dsHsBind dflags- (PatBind { pat_lhs = pat, pat_rhs = grhss, pat_rhs_ty = ty- , pat_ticks = (rhs_tick, var_ticks) })+dsHsBind dflags (PatBind { pat_lhs = pat, pat_rhs = grhss+ , pat_rhs_ty = ty+ , pat_ticks = (rhs_tick, var_ticks) }) = do { body_expr <- dsGuarded grhss ty ; let body' = mkOptTickBox rhs_tick body_expr pat' = decideBangHood dflags pat@@ -174,48 +177,73 @@ else [] ; return (force_var', sel_binds) } - -- A common case: one exported variable, only non-strict binds- -- Non-recursive bindings come through this way- -- So do self-recursive bindings- -- Bindings with complete signatures are AbsBindsSigs, below-dsHsBind dflags- (AbsBinds { abs_tvs = tyvars, abs_ev_vars = dicts- , abs_exports = [export]- , abs_ev_binds = ev_binds, abs_binds = binds })- | ABE { abe_wrap = wrap, abe_poly = global- , abe_mono = local, abe_prags = prags } <- export- , not (xopt LangExt.Strict dflags) -- Handle strict binds- , not (anyBag (isBangedBind . unLoc) binds) -- in the next case- = -- See Note [AbsBinds wrappers] in HsBinds- addDictsDs (toTcTypeBag (listToBag dicts)) $- -- addDictsDs: push type constraints deeper for pattern match check- do { (force_vars, bind_prs) <- dsLHsBinds binds- ; let core_bind = Rec bind_prs- ; ds_binds <- dsTcEvBinds_s ev_binds- ; core_wrap <- dsHsWrapper wrap -- Usually the identity+dsHsBind dflags (AbsBinds { abs_tvs = tyvars, abs_ev_vars = dicts+ , abs_exports = exports+ , abs_ev_binds = ev_binds+ , abs_binds = binds, abs_sig = has_sig })+ = do { ds_binds <- addDictsDs (toTcTypeBag (listToBag dicts)) $+ dsLHsBinds binds+ -- addDictsDs: push type constraints deeper+ -- for inner pattern match check + ; ds_ev_binds <- dsTcEvBinds_s ev_binds++ -- dsAbsBinds does the hard work+ ; dsAbsBinds dflags tyvars dicts exports ds_ev_binds ds_binds has_sig }++dsHsBind _ (PatSynBind{}) = panic "dsHsBind: PatSynBind"+++-----------------------+dsAbsBinds :: DynFlags+ -> [TyVar] -> [EvVar] -> [ABExport GhcTc]+ -> [CoreBind] -- Desugared evidence bindings+ -> ([Id], [(Id,CoreExpr)]) -- Desugared value bindings+ -> Bool -- Single binding with signature+ -> DsM ([Id], [(Id,CoreExpr)])++dsAbsBinds dflags tyvars dicts exports+ ds_ev_binds (force_vars, bind_prs) has_sig++ -- A very important common case: one exported variable+ -- Non-recursive bindings come through this way+ -- So do self-recursive bindings+ | [export] <- exports+ , ABE { abe_poly = global_id, abe_mono = local_id+ , abe_wrap = wrap, abe_prags = prags } <- export+ , Just force_vars' <- case force_vars of+ [] -> Just []+ [v] | v == local_id -> Just [global_id]+ _ -> Nothing+ -- If there is a variable to force, it's just the+ -- single variable we are binding here+ = do { core_wrap <- dsHsWrapper wrap -- Usually the identity+ ; let rhs = core_wrap $ mkLams tyvars $ mkLams dicts $- mkCoreLets ds_binds $- mkLet core_bind $- Var local+ mkCoreLets ds_ev_binds $+ body++ body | has_sig+ , [(_, lrhs)] <- bind_prs+ = lrhs+ | otherwise+ = mkLetRec bind_prs (Var local_id)+ ; (spec_binds, rules) <- dsSpecs rhs prags - ; let global' = addIdSpecialisations global rules- main_bind = makeCorePair dflags global' (isDefaultMethod prags)- (dictArity dicts) rhs+ ; let global_id' = addIdSpecialisations global_id rules+ main_bind = makeCorePair dflags global_id'+ (isDefaultMethod prags)+ (dictArity dicts) rhs - ; ASSERT(null force_vars)- return ([], main_bind : fromOL spec_binds) }+ ; return (force_vars', main_bind : fromOL spec_binds) } - -- Another common case: no tyvars, no dicts- -- In this case we can have a much simpler desugaring-dsHsBind dflags- (AbsBinds { abs_tvs = [], abs_ev_vars = []- , abs_exports = exports- , abs_ev_binds = ev_binds, abs_binds = binds })- = do { (force_vars, bind_prs) <- dsLHsBinds binds- ; let mk_bind (ABE { abe_wrap = wrap+ -- Another common case: no tyvars, no dicts+ -- In this case we can have a much simpler desugaring+ | null tyvars, null dicts++ = do { let mk_bind (ABE { abe_wrap = wrap , abe_poly = global , abe_mono = local , abe_prags = prags })@@ -225,42 +253,35 @@ 0 (core_wrap (Var local))) } ; main_binds <- mapM mk_bind exports - ; ds_binds <- dsTcEvBinds_s ev_binds- ; return (force_vars, flattenBinds ds_binds ++ bind_prs ++ main_binds) }+ ; return (force_vars, flattenBinds ds_ev_binds ++ bind_prs ++ main_binds) } -dsHsBind dflags- (AbsBinds { abs_tvs = tyvars, abs_ev_vars = dicts- , abs_exports = exports, abs_ev_binds = ev_binds- , abs_binds = binds })- -- See Note [Desugaring AbsBinds]- = addDictsDs (toTcTypeBag (listToBag dicts)) $- -- addDictsDs: push type constraints deeper for pattern match check- do { (local_force_vars, bind_prs) <- dsLHsBinds binds- ; let core_bind = Rec [ makeCorePair dflags (add_inline lcl_id) False 0 rhs+ -- The general case+ -- See Note [Desugaring AbsBinds]+ | otherwise+ = do { let core_bind = Rec [ makeCorePair dflags (add_inline lcl_id) False 0 rhs | (lcl_id, rhs) <- bind_prs ] -- Monomorphic recursion possible, hence Rec- new_force_vars = get_new_force_vars local_force_vars- locals = map abe_mono exports- all_locals = locals ++ new_force_vars- tup_expr = mkBigCoreVarTup all_locals- tup_ty = exprType tup_expr- ; ds_binds <- dsTcEvBinds_s ev_binds- ; let poly_tup_rhs = mkLams tyvars $ mkLams dicts $- mkCoreLets ds_binds $- mkLet core_bind $- tup_expr+ new_force_vars = get_new_force_vars force_vars+ locals = map abe_mono exports+ all_locals = locals ++ new_force_vars+ tup_expr = mkBigCoreVarTup all_locals+ tup_ty = exprType tup_expr+ ; let poly_tup_rhs = mkLams tyvars $ mkLams dicts $+ mkCoreLets ds_ev_binds $+ mkLet core_bind $+ tup_expr - ; poly_tup_id <- newSysLocalDs (exprType poly_tup_rhs)+ ; poly_tup_id <- newSysLocalDs (exprType poly_tup_rhs) -- Find corresponding global or make up a new one: sometimes -- we need to make new export to desugar strict binds, see -- Note [Desugar Strict binds]- ; (exported_force_vars, extra_exports) <- get_exports local_force_vars+ ; (exported_force_vars, extra_exports) <- get_exports force_vars - ; let mk_bind (ABE { abe_wrap = wrap- , abe_poly = global- , abe_mono = local, abe_prags = spec_prags })- -- See Note [AbsBinds wrappers] in HsBinds+ ; let mk_bind (ABE { abe_wrap = wrap+ , abe_poly = global+ , abe_mono = local, abe_prags = spec_prags })+ -- See Note [AbsBinds wrappers] in HsBinds = do { tup_id <- newSysLocalDs tup_ty ; core_wrap <- dsHsWrapper wrap ; let rhs = core_wrap $ mkLams tyvars $ mkLams dicts $@@ -275,13 +296,13 @@ -- Id is just the selector. Hmm. ; return ((global', rhs) : fromOL spec_binds) } - ; export_binds_s <- mapM mk_bind (exports ++ extra_exports)+ ; export_binds_s <- mapM mk_bind (exports ++ extra_exports) - ; return (exported_force_vars- ,(poly_tup_id, poly_tup_rhs) :+ ; return ( exported_force_vars+ , (poly_tup_id, poly_tup_rhs) : concat export_binds_s) } where- inline_env :: IdEnv Id -- Maps a monomorphic local Id to one with+ inline_env :: IdEnv Id -- Maps a monomorphic local Id to one with -- the inline pragma from the source -- The type checker put the inline pragma -- on the *global* Id, so we need to transfer it@@ -308,7 +329,7 @@ [] lcls -- find exports or make up new exports for force variables- get_exports :: [Id] -> DsM ([Id], [ABExport Id])+ get_exports :: [Id] -> DsM ([Id], [ABExport GhcTc]) get_exports lcls = foldM (\(glbls, exports) lcl -> case lookupVarEnv global_env lcl of@@ -321,57 +342,10 @@ mk_export local = do global <- newSysLocalDs (exprType (mkLams tyvars (mkLams dicts (Var local))))- return (ABE {abe_poly = global- ,abe_mono = local- ,abe_wrap = WpHole- ,abe_prags = SpecPrags []})---- AbsBindsSig is a combination of AbsBinds and FunBind-dsHsBind dflags (AbsBindsSig { abs_tvs = tyvars, abs_ev_vars = dicts- , abs_sig_export = global- , abs_sig_prags = prags- , abs_sig_ev_bind = ev_bind- , abs_sig_bind = bind })- | L bind_loc FunBind { fun_matches = matches- , fun_co_fn = co_fn- , fun_tick = tick } <- bind- = putSrcSpanDs bind_loc $- addDictsDs (toTcTypeBag (listToBag dicts)) $- -- addDictsDs: push type constraints deeper for pattern match check- do { (args, body) <- matchWrapper- (mkPrefixFunRhs (noLoc $ idName global))- Nothing matches- ; core_wrap <- dsHsWrapper co_fn- ; let body' = mkOptTickBox tick body- fun_rhs = core_wrap (mkLams args body')- force_vars- | xopt LangExt.Strict dflags- , matchGroupArity matches == 0 -- no need to force lambdas- = [global]- | isBangedBind (unLoc bind)- = [global]- | otherwise- = []-- ; ds_binds <- dsTcEvBinds ev_bind- ; let rhs = mkLams tyvars $- mkLams dicts $- mkCoreLets ds_binds $- fun_rhs-- ; (spec_binds, rules) <- dsSpecs rhs prags- ; let global' = addIdSpecialisations global rules- main_bind = makeCorePair dflags global' (isDefaultMethod prags)- (dictArity dicts) rhs-- ; return (force_vars, main_bind : fromOL spec_binds) }-- | otherwise- = pprPanic "dsHsBind: AbsBindsSig" (ppr bind)--dsHsBind _ (PatSynBind{}) = panic "dsHsBind: PatSynBind"--+ return (ABE { abe_poly = global+ , abe_mono = local+ , abe_wrap = WpHole+ , abe_prags = SpecPrags [] }) -- | This is where we apply INLINE and INLINABLE pragmas. All we need to -- do is to attach the unfolding information to the Id.@@ -381,17 +355,19 @@ -- the unfolding in the interface file is made in `TidyPgm.addExternal` -- using this information. -------------------------makeCorePair :: DynFlags -> Id -> Bool -> Arity -> CoreExpr -> (Id, CoreExpr)+makeCorePair :: DynFlags -> Id -> Bool -> Arity -> CoreExpr+ -> (Id, CoreExpr) makeCorePair dflags gbl_id is_default_method dict_arity rhs- | is_default_method -- Default methods are *always* inlined+ | is_default_method -- Default methods are *always* inlined+ -- See Note [INLINE and default methods] in TcInstDcls = (gbl_id `setIdUnfolding` mkCompulsoryUnfolding rhs, rhs) | otherwise = case inlinePragmaSpec inline_prag of- EmptyInlineSpec -> (gbl_id, rhs)- NoInline -> (gbl_id, rhs)- Inlinable -> (gbl_id `setIdUnfolding` inlinable_unf, rhs)- Inline -> inline_pair+ NoUserInline -> (gbl_id, rhs)+ NoInline -> (gbl_id, rhs)+ Inlinable -> (gbl_id `setIdUnfolding` inlinable_unf, rhs)+ Inline -> inline_pair where inline_prag = idInlinePragma gbl_id@@ -428,7 +404,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~ Common special case: no type or dictionary abstraction This is a bit less trivial than you might suppose-The naive way woudl be to desguar to something like+The naive way would be to desugar to something like f_lcl = ...f_lcl... -- The "binds" from AbsBinds M.f = f_lcl -- Generated from "exports" But we don't want that, because if M.f isn't exported,@@ -544,6 +520,7 @@ Note [Desugar Strict binds] ~~~~~~~~~~~~~~~~~~~~~~~~~~~+See https://ghc.haskell.org/trac/ghc/wiki/StrictPragma Desugaring strict variable bindings looks as follows (core below ==>) @@ -629,7 +606,7 @@ is *not* an unlifted bind. Unlifted binds are detected by HsUtils.isUnliftedHsBind. -Define a "banged bind" to have a top-level bang. Detected by HsPat.isBangedPatBind.+Define a "banged bind" to have a top-level bang. Detected by HsPat.isBangedHsBind. Define a "strict bind" to be either an unlifted bind or a banged bind. The restrictions are:@@ -678,7 +655,7 @@ = putSrcSpanDs loc $ do { warnDs NoReason (text "Ignoring useless SPECIALISE pragma for NOINLINE function:" <+> quotes (ppr poly_id))- ; return Nothing } -- Function is NOINLINE, and the specialiation inherits that+ ; return Nothing } -- Function is NOINLINE, and the specialisation inherits that -- See Note [Activation pragmas for SPECIALISE] | otherwise@@ -1038,7 +1015,7 @@ RULE forall s (d :: MonadAbstractIOST (ReaderT s)). useAbstractMonad (ReaderT s) d = $suseAbstractMonad s - Trac #8848 is a good example of where there are some intersting+ Trac #8848 is a good example of where there are some interesting dictionary bindings to discard. The drop_dicts algorithm is based on these observations:@@ -1262,10 +1239,12 @@ -- Note that we use the kind of the type, not the TyCon from which it -- is constructed since the latter may be kind polymorphic whereas the -- former we know is not (we checked in the solver).- ; return $ mkApps (Var mkTrCon) [ Type (typeKind ty)- , Type ty- , tc_rep- , kind_args ]+ ; let expr = mkApps (Var mkTrCon) [ Type (typeKind ty)+ , Type ty+ , tc_rep+ , kind_args ]+ -- ; pprRuntimeTrace "Trace mkTrTyCon" (ppr expr) expr+ ; return expr } ds_ev_typeable ty (EvTypeableTyApp ev1 ev2)@@ -1276,8 +1255,11 @@ -- mkTrApp :: forall k1 k2 (a :: k1 -> k2) (b :: k1). -- TypeRep a -> TypeRep b -> TypeRep (a b) ; let (k1, k2) = splitFunTy (typeKind t1)- ; return $ mkApps (mkTyApps (Var mkTrApp) [ k1, k2, t1, t2 ])- [ e1, e2 ] }+ ; let expr = mkApps (mkTyApps (Var mkTrApp) [ k1, k2, t1, t2 ])+ [ e1, e2 ]+ -- ; pprRuntimeTrace "Trace mkTrApp" (ppr expr) expr+ ; return expr+ } ds_ev_typeable ty (EvTypeableTrFun ev1 ev2) | Just (t1,t2) <- splitFunTy_maybe ty
deSugar/DsCCall.hs view
@@ -18,6 +18,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import DsMonad@@ -134,7 +136,7 @@ -- always returns a non-levity-polymorphic expression unboxArg arg- -- Primtive types: nothing to unbox+ -- Primitive types: nothing to unbox | isPrimitiveType arg_ty = return (arg, \body -> body) @@ -202,7 +204,7 @@ -- Takes the result of the user-level ccall: -- either (IO t),--- or maybe just t for an side-effect-free call+-- or maybe just t for a side-effect-free call -- Returns a wrapper for the primitive ccall itself, along with the -- type of the result of the primitive ccall. This result type -- will be of the form@@ -343,7 +345,7 @@ -- Data types with a single constructor, which has a single arg -- This includes types like Ptr and ForeignPtr | Just (tycon, tycon_arg_tys) <- maybe_tc_app- , Just data_con <- isDataProductTyCon_maybe tycon -- One construtor, no existentials+ , Just data_con <- isDataProductTyCon_maybe tycon -- One constructor, no existentials , [unwrapped_res_ty] <- dataConInstOrigArgTys data_con tycon_arg_tys -- One argument = do { dflags <- getDynFlags ; (maybe_ty, wrapper) <- resultWrapper unwrapped_res_ty
deSugar/DsExpr.hs view
@@ -7,12 +7,15 @@ -} {-# LANGUAGE CPP, MultiWayIf #-}+{-# LANGUAGE TypeFamilies #-} module DsExpr ( dsExpr, dsLExpr, dsLExprNoLP, dsLocalBinds , dsValBinds, dsLit, dsSyntaxExpr ) where #include "HsVersions.h" +import GhcPrelude+ import Match import MatchLit import DsBinds@@ -66,7 +69,7 @@ ************************************************************************ -} -dsLocalBinds :: LHsLocalBinds Id -> CoreExpr -> DsM CoreExpr+dsLocalBinds :: LHsLocalBinds GhcTc -> CoreExpr -> DsM CoreExpr dsLocalBinds (L _ EmptyLocalBinds) body = return body dsLocalBinds (L loc (HsValBinds binds)) body = putSrcSpanDs loc $ dsValBinds binds body@@ -74,12 +77,12 @@ ------------------------- -- caller sets location-dsValBinds :: HsValBinds Id -> CoreExpr -> DsM CoreExpr+dsValBinds :: HsValBinds GhcTc -> CoreExpr -> DsM CoreExpr dsValBinds (ValBindsOut binds _) body = foldrM ds_val_bind body binds dsValBinds (ValBindsIn {}) _ = panic "dsValBinds ValBindsIn" --------------------------dsIPBinds :: HsIPBinds Id -> CoreExpr -> DsM CoreExpr+dsIPBinds :: HsIPBinds GhcTc -> CoreExpr -> DsM CoreExpr dsIPBinds (IPBinds ip_binds ev_binds) body = do { ds_binds <- dsTcEvBinds ev_binds ; let inner = mkCoreLets ds_binds body@@ -93,7 +96,7 @@ ------------------------- -- caller sets location-ds_val_bind :: (RecFlag, LHsBinds Id) -> CoreExpr -> DsM CoreExpr+ds_val_bind :: (RecFlag, LHsBinds GhcTc) -> CoreExpr -> DsM CoreExpr -- Special case for bindings which bind unlifted variables -- We need to do a case right away, rather than building -- a tuple and doing selections.@@ -129,8 +132,6 @@ where is_polymorphic (AbsBinds { abs_tvs = tvs, abs_ev_vars = evs }) = not (null tvs && null evs)- is_polymorphic (AbsBindsSig { abs_tvs = tvs, abs_ev_vars = evs })- = not (null tvs && null evs) is_polymorphic _ = False unlifted_must_be_bang bind@@ -173,7 +174,7 @@ -- only have to deal with lifted ones now; so Rec is ok -------------------dsUnliftedBind :: HsBind Id -> CoreExpr -> DsM CoreExpr+dsUnliftedBind :: HsBind GhcTc -> CoreExpr -> DsM CoreExpr dsUnliftedBind (AbsBinds { abs_tvs = [], abs_ev_vars = [] , abs_exports = exports , abs_ev_binds = ev_binds@@ -185,15 +186,6 @@ ; ds_binds <- dsTcEvBinds_s ev_binds ; return (mkCoreLets ds_binds body2) } -dsUnliftedBind (AbsBindsSig { abs_tvs = []- , abs_ev_vars = []- , abs_sig_export = poly- , abs_sig_ev_bind = ev_bind- , abs_sig_bind = L _ bind }) body- = do { ds_binds <- dsTcEvBinds ev_bind- ; body' <- dsUnliftedBind (bind { fun_id = noLoc poly }) body- ; return (mkCoreLets ds_binds body') }- dsUnliftedBind (FunBind { fun_id = L l fun , fun_matches = matches , fun_co_fn = co_fn@@ -228,7 +220,7 @@ ************************************************************************ -} -dsLExpr :: LHsExpr Id -> DsM CoreExpr+dsLExpr :: LHsExpr GhcTc -> DsM CoreExpr dsLExpr (L loc e) = putSrcSpanDs loc $@@ -244,59 +236,65 @@ -- be an argument to some other function. -- See Note [Levity polymorphism checking] in DsMonad -- See Note [Levity polymorphism invariants] in CoreSyn-dsLExprNoLP :: LHsExpr Id -> DsM CoreExpr+dsLExprNoLP :: LHsExpr GhcTc -> DsM CoreExpr dsLExprNoLP (L loc e) = putSrcSpanDs loc $ do { e' <- dsExpr e ; dsNoLevPolyExpr e' (text "In the type of expression:" <+> ppr e) ; return e' } -dsExpr :: HsExpr Id -> DsM CoreExpr-dsExpr (HsPar e) = dsLExpr e-dsExpr (ExprWithTySigOut e _) = dsLExpr e-dsExpr (HsVar (L _ var)) = return (varToCoreExpr var)- -- See Note [Desugaring vars]-dsExpr (HsUnboundVar {}) = panic "dsExpr: HsUnboundVar" -- Typechecker eliminates them-dsExpr (HsConLikeOut con) = return (dsConLike con)-dsExpr (HsIPVar _) = panic "dsExpr: HsIPVar"-dsExpr (HsOverLabel{}) = panic "dsExpr: HsOverLabel"-dsExpr (HsLit lit) = dsLit lit-dsExpr (HsOverLit lit) = dsOverLit lit+dsExpr :: HsExpr GhcTc -> DsM CoreExpr+dsExpr = ds_expr False -dsExpr (HsWrap co_fn e)- = do { e' <- dsExpr e+ds_expr :: Bool -- are we directly inside an HsWrap?+ -- See Wrinkle in Note [Detecting forced eta expansion]+ -> HsExpr GhcTc -> DsM CoreExpr+ds_expr _ (HsPar e) = dsLExpr e+ds_expr _ (ExprWithTySigOut e _) = dsLExpr e+ds_expr w (HsVar (L _ var)) = dsHsVar w var+ds_expr _ (HsUnboundVar {}) = panic "dsExpr: HsUnboundVar" -- Typechecker eliminates them+ds_expr w (HsConLikeOut con) = dsConLike w con+ds_expr _ (HsIPVar _) = panic "dsExpr: HsIPVar"+ds_expr _ (HsOverLabel{}) = panic "dsExpr: HsOverLabel"+ds_expr _ (HsLit lit) = dsLit (convertLit lit)+ds_expr _ (HsOverLit lit) = dsOverLit lit++ds_expr _ (HsWrap co_fn e)+ = do { e' <- ds_expr True e ; wrap' <- dsHsWrapper co_fn ; dflags <- getDynFlags ; let wrapped_e = wrap' e'- ; warnAboutIdentities dflags e' (exprType wrapped_e)+ wrapped_ty = exprType wrapped_e+ ; checkForcedEtaExpansion e wrapped_ty -- See Note [Detecting forced eta expansion]+ ; warnAboutIdentities dflags e' wrapped_ty ; return wrapped_e } -dsExpr (NegApp (L loc (HsOverLit lit@(OverLit { ol_val = HsIntegral src i })))- neg_expr)+ds_expr _ (NegApp (L loc (HsOverLit lit@(OverLit { ol_val = HsIntegral i })))+ neg_expr) = do { expr' <- putSrcSpanDs loc $ do { dflags <- getDynFlags ; warnAboutOverflowedLiterals dflags- (lit { ol_val = HsIntegral src (-i) })+ (lit { ol_val = HsIntegral (negateIntegralLit i) }) ; dsOverLit' dflags lit } ; dsSyntaxExpr neg_expr [expr'] } -dsExpr (NegApp expr neg_expr)+ds_expr _ (NegApp expr neg_expr) = do { expr' <- dsLExpr expr ; dsSyntaxExpr neg_expr [expr'] } -dsExpr (HsLam a_Match)+ds_expr _ (HsLam a_Match) = uncurry mkLams <$> matchWrapper LambdaExpr Nothing a_Match -dsExpr (HsLamCase matches)+ds_expr _ (HsLamCase matches) = do { ([discrim_var], matching_code) <- matchWrapper CaseAlt Nothing matches ; return $ Lam discrim_var matching_code } -dsExpr e@(HsApp fun arg)+ds_expr _ e@(HsApp fun arg) = do { fun' <- dsLExpr fun ; dsWhenNoErrs (dsLExprNoLP arg) (\arg' -> mkCoreAppDs (text "HsApp" <+> ppr e) fun' arg') } -dsExpr (HsAppTypeOut e _)+ds_expr _ (HsAppTypeOut e _) -- ignore type arguments here; they're in the wrappers instead at this point = dsLExpr e @@ -340,19 +338,19 @@ will sort it out. -} -dsExpr e@(OpApp e1 op _ e2)+ds_expr _ e@(OpApp e1 op _ e2) = -- for the type of y, we need the type of op's 2nd argument do { op' <- dsLExpr op ; dsWhenNoErrs (mapM dsLExprNoLP [e1, e2]) (\exprs' -> mkCoreAppsDs (text "opapp" <+> ppr e) op' exprs') } -dsExpr (SectionL expr op) -- Desugar (e !) to ((!) e)+ds_expr _ (SectionL expr op) -- Desugar (e !) to ((!) e) = do { op' <- dsLExpr op ; dsWhenNoErrs (dsLExprNoLP expr) (\expr' -> mkCoreAppDs (text "sectionl" <+> ppr expr) op' expr') } -- dsLExpr (SectionR op expr) -- \ x -> op x expr-dsExpr e@(SectionR op expr) = do+ds_expr _ e@(SectionR op expr) = do core_op <- dsLExpr op -- for the type of x, we need the type of op's 2nd argument let (x_ty:y_ty:_, _) = splitFunTys (exprType core_op)@@ -363,7 +361,7 @@ Lam x_id (mkCoreAppsDs (text "sectionr" <+> ppr e) core_op [Var x_id, Var y_id])) -dsExpr (ExplicitTuple tup_args boxity)+ds_expr _ (ExplicitTuple tup_args boxity) = do { let go (lam_vars, args) (L _ (Missing ty)) -- For every missing expression, we need -- another lambda in the desugaring.@@ -380,14 +378,14 @@ (\(lam_vars, args) -> mkCoreLams lam_vars $ mkCoreTupBoxity boxity args) } -dsExpr (ExplicitSum alt arity expr types)+ds_expr _ (ExplicitSum alt arity expr types) = do { dsWhenNoErrs (dsLExprNoLP expr) (\core_expr -> mkCoreConApps (sumDataCon alt arity) (map (Type . getRuntimeRep) types ++ map Type types ++ [core_expr]) ) } -dsExpr (HsSCC _ cc expr@(L loc _)) = do+ds_expr _ (HsSCC _ cc expr@(L loc _)) = do dflags <- getDynFlags if gopt Opt_SccProfilingOn dflags then do@@ -398,31 +396,31 @@ <$> dsLExpr expr else dsLExpr expr -dsExpr (HsCoreAnn _ _ expr)+ds_expr _ (HsCoreAnn _ _ expr) = dsLExpr expr -dsExpr (HsCase discrim matches)+ds_expr _ (HsCase discrim matches) = do { core_discrim <- dsLExpr discrim ; ([discrim_var], matching_code) <- matchWrapper CaseAlt (Just discrim) matches ; return (bindNonRec discrim_var core_discrim matching_code) } -- Pepe: The binds are in scope in the body but NOT in the binding group -- This is to avoid silliness in breakpoints-dsExpr (HsLet binds body) = do+ds_expr _ (HsLet binds body) = do body' <- dsLExpr body dsLocalBinds binds body' -- We need the `ListComp' form to use `deListComp' (rather than the "do" form) -- because the interpretation of `stmts' depends on what sort of thing it is. ---dsExpr (HsDo ListComp (L _ stmts) res_ty) = dsListComp stmts res_ty-dsExpr (HsDo PArrComp (L _ stmts) _) = dsPArrComp (map unLoc stmts)-dsExpr (HsDo DoExpr (L _ stmts) _) = dsDo stmts-dsExpr (HsDo GhciStmtCtxt (L _ stmts) _) = dsDo stmts-dsExpr (HsDo MDoExpr (L _ stmts) _) = dsDo stmts-dsExpr (HsDo MonadComp (L _ stmts) _) = dsMonadComp stmts+ds_expr _ (HsDo ListComp (L _ stmts) res_ty) = dsListComp stmts res_ty+ds_expr _ (HsDo PArrComp (L _ stmts) _) = dsPArrComp (map unLoc stmts)+ds_expr _ (HsDo DoExpr (L _ stmts) _) = dsDo stmts+ds_expr _ (HsDo GhciStmtCtxt (L _ stmts) _) = dsDo stmts+ds_expr _ (HsDo MDoExpr (L _ stmts) _) = dsDo stmts+ds_expr _ (HsDo MonadComp (L _ stmts) _) = dsMonadComp stmts -dsExpr (HsIf mb_fun guard_expr then_expr else_expr)+ds_expr _ (HsIf mb_fun guard_expr then_expr else_expr) = do { pred <- dsLExpr guard_expr ; b1 <- dsLExpr then_expr ; b2 <- dsLExpr else_expr@@ -430,7 +428,7 @@ Just fun -> dsSyntaxExpr fun [pred, b1, b2] Nothing -> return $ mkIfThenElse pred b1 b2 } -dsExpr (HsMultiIf res_ty alts)+ds_expr _ (HsMultiIf res_ty alts) | null alts = mkErrorExpr @@ -449,16 +447,16 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -} -dsExpr (ExplicitList elt_ty wit xs)+ds_expr _ (ExplicitList elt_ty wit xs) = dsExplicitList elt_ty wit xs -- We desugar [:x1, ..., xn:] as -- singletonP x1 +:+ ... +:+ singletonP xn ---dsExpr (ExplicitPArr ty []) = do+ds_expr _ (ExplicitPArr ty []) = do emptyP <- dsDPHBuiltin emptyPVar return (Var emptyP `App` Type ty)-dsExpr (ExplicitPArr ty xs) = do+ds_expr _ (ExplicitPArr ty xs) = do singletonP <- dsDPHBuiltin singletonPVar appP <- dsDPHBuiltin appPVar xs' <- mapM dsLExprNoLP xs@@ -467,19 +465,19 @@ return . foldr1 (binary appP) $ map (unary singletonP) xs' -dsExpr (ArithSeq expr witness seq)+ds_expr _ (ArithSeq expr witness seq) = case witness of Nothing -> dsArithSeq expr seq Just fl -> do { newArithSeq <- dsArithSeq expr seq ; dsSyntaxExpr fl [newArithSeq] } -dsExpr (PArrSeq expr (FromTo from to))+ds_expr _ (PArrSeq expr (FromTo from to)) = mkApps <$> dsExpr expr <*> mapM dsLExprNoLP [from, to] -dsExpr (PArrSeq expr (FromThenTo from thn to))+ds_expr _ (PArrSeq expr (FromThenTo from thn to)) = mkApps <$> dsExpr expr <*> mapM dsLExprNoLP [from, thn, to] -dsExpr (PArrSeq _ _)+ds_expr _ (PArrSeq _ _) = panic "DsExpr.dsExpr: Infinite parallel array!" -- the parser shouldn't have generated it and the renamer and typechecker -- shouldn't have let it through@@ -495,7 +493,7 @@ g = ... makeStatic loc f ... -} -dsExpr (HsStatic _ expr@(L loc _)) = do+ds_expr _ (HsStatic _ expr@(L loc _)) = do expr_ds <- dsLExprNoLP expr let ty = exprType expr_ds makeStaticId <- dsLookupGlobalId makeStaticName@@ -537,8 +535,8 @@ constructor @C@, setting all of @C@'s fields to bottom. -} -dsExpr (RecordCon { rcon_con_expr = con_expr, rcon_flds = rbinds- , rcon_con_like = con_like })+ds_expr _ (RecordCon { rcon_con_expr = con_expr, rcon_flds = rbinds+ , rcon_con_like = con_like }) = do { con_expr' <- dsExpr con_expr ; let (arg_tys, _) = tcSplitFunTys (exprType con_expr')@@ -596,10 +594,10 @@ -} -dsExpr expr@(RecordUpd { rupd_expr = record_expr, rupd_flds = fields- , rupd_cons = cons_to_upd- , rupd_in_tys = in_inst_tys, rupd_out_tys = out_inst_tys- , rupd_wrap = dict_req_wrap } )+ds_expr _ expr@(RecordUpd { rupd_expr = record_expr, rupd_flds = fields+ , rupd_cons = cons_to_upd+ , rupd_in_tys = in_inst_tys, rupd_out_tys = out_inst_tys+ , rupd_wrap = dict_req_wrap } ) | null fields = dsLExpr record_expr | otherwise@@ -625,7 +623,7 @@ ; return (add_field_binds field_binds' $ bindNonRec discrim_var record_expr' matching_code) } where- ds_field :: LHsRecUpdField Id -> DsM (Name, Id, CoreExpr)+ ds_field :: LHsRecUpdField GhcTc -> DsM (Name, Id, CoreExpr) -- Clone the Id in the HsRecField, because its Name is that -- of the record selector, and we must not make that a local binder -- else we shadow other uses of the record selector@@ -663,7 +661,7 @@ mk_val_arg fl pat_arg_id = nlHsVar (lookupNameEnv upd_fld_env (flSelector fl) `orElse` pat_arg_id) - inst_con = noLoc $ HsWrap wrap (HsConLikeOut con)+ inst_con = noLoc $ mkHsWrap wrap (HsConLikeOut con) -- Reconstruct with the WrapId so that unpacking happens -- The order here is because of the order in `TcPatSyn`. wrap = mkWpEvVarApps theta_vars <.>@@ -715,16 +713,16 @@ -- Template Haskell stuff -dsExpr (HsRnBracketOut _ _) = panic "dsExpr HsRnBracketOut"-dsExpr (HsTcBracketOut x ps) = dsBracket x ps-dsExpr (HsSpliceE s) = pprPanic "dsExpr:splice" (ppr s)+ds_expr _ (HsRnBracketOut _ _) = panic "dsExpr HsRnBracketOut"+ds_expr _ (HsTcBracketOut x ps) = dsBracket x ps+ds_expr _ (HsSpliceE s) = pprPanic "dsExpr:splice" (ppr s) -- Arrow notation extension-dsExpr (HsProc pat cmd) = dsProcExpr pat cmd+ds_expr _ (HsProc pat cmd) = dsProcExpr pat cmd -- Hpc Support -dsExpr (HsTick tickish e) = do+ds_expr _ (HsTick tickish e) = do e' <- dsLExpr e return (Tick tickish e') @@ -735,33 +733,33 @@ -- (did you go here: YES or NO), but will effect accurate -- tick counting. -dsExpr (HsBinTick ixT ixF e) = do+ds_expr _ (HsBinTick ixT ixF e) = do e2 <- dsLExpr e do { ASSERT(exprType e2 `eqType` boolTy) mkBinaryTickBox ixT ixF e2 } -dsExpr (HsTickPragma _ _ _ expr) = do+ds_expr _ (HsTickPragma _ _ _ expr) = do dflags <- getDynFlags if gopt Opt_Hpc dflags then panic "dsExpr:HsTickPragma" else dsLExpr expr -- HsSyn constructs that just shouldn't be here:-dsExpr (ExprWithTySig {}) = panic "dsExpr:ExprWithTySig"-dsExpr (HsBracket {}) = panic "dsExpr:HsBracket"-dsExpr (HsArrApp {}) = panic "dsExpr:HsArrApp"-dsExpr (HsArrForm {}) = panic "dsExpr:HsArrForm"-dsExpr (EWildPat {}) = panic "dsExpr:EWildPat"-dsExpr (EAsPat {}) = panic "dsExpr:EAsPat"-dsExpr (EViewPat {}) = panic "dsExpr:EViewPat"-dsExpr (ELazyPat {}) = panic "dsExpr:ELazyPat"-dsExpr (HsAppType {}) = panic "dsExpr:HsAppType" -- removed by typechecker-dsExpr (HsDo {}) = panic "dsExpr:HsDo"-dsExpr (HsRecFld {}) = panic "dsExpr:HsRecFld"+ds_expr _ (ExprWithTySig {}) = panic "dsExpr:ExprWithTySig"+ds_expr _ (HsBracket {}) = panic "dsExpr:HsBracket"+ds_expr _ (HsArrApp {}) = panic "dsExpr:HsArrApp"+ds_expr _ (HsArrForm {}) = panic "dsExpr:HsArrForm"+ds_expr _ (EWildPat {}) = panic "dsExpr:EWildPat"+ds_expr _ (EAsPat {}) = panic "dsExpr:EAsPat"+ds_expr _ (EViewPat {}) = panic "dsExpr:EViewPat"+ds_expr _ (ELazyPat {}) = panic "dsExpr:ELazyPat"+ds_expr _ (HsAppType {}) = panic "dsExpr:HsAppType" -- removed by typechecker+ds_expr _ (HsDo {}) = panic "dsExpr:HsDo"+ds_expr _ (HsRecFld {}) = panic "dsExpr:HsRecFld" -------------------------------dsSyntaxExpr :: SyntaxExpr Id -> [CoreExpr] -> DsM CoreExpr+dsSyntaxExpr :: SyntaxExpr GhcTc -> [CoreExpr] -> DsM CoreExpr dsSyntaxExpr (SyntaxExpr { syn_expr = expr , syn_arg_wraps = arg_wraps , syn_res_wrap = res_wrap })@@ -775,7 +773,7 @@ where mk_doc n = text "In the" <+> speakNth n <+> text "argument of" <+> quotes (ppr expr) -findField :: [LHsRecField Id arg] -> Name -> [arg]+findField :: [LHsRecField GhcTc arg] -> Name -> [arg] findField rbinds sel = [hsRecFieldArg fld | L _ fld <- rbinds , sel == idName (unLoc $ hsRecFieldId fld) ]@@ -840,15 +838,15 @@ maxBuildLength :: Int maxBuildLength = 32 -dsExplicitList :: Type -> Maybe (SyntaxExpr Id) -> [LHsExpr Id]+dsExplicitList :: Type -> Maybe (SyntaxExpr GhcTc) -> [LHsExpr GhcTc] -> DsM CoreExpr -- See Note [Desugaring explicit lists] dsExplicitList elt_ty Nothing xs = do { dflags <- getDynFlags ; xs' <- mapM dsLExprNoLP xs- ; if length xs' > maxBuildLength+ ; if xs' `lengthExceeds` maxBuildLength -- Don't generate builds if the list is very long.- || length xs' == 0+ || null xs' -- Don't generate builds when the [] constructor will do || not (gopt Opt_EnableRewriteRules dflags) -- Rewrite rules off -- Don't generate a build if there are no rules to eliminate it!@@ -864,7 +862,7 @@ ; dflags <- getDynFlags ; dsSyntaxExpr fln [mkIntExprInt dflags (length xs), list] } -dsArithSeq :: PostTcExpr -> (ArithSeqInfo Id) -> DsM CoreExpr+dsArithSeq :: PostTcExpr -> (ArithSeqInfo GhcTc) -> DsM CoreExpr dsArithSeq expr (From from) = App <$> dsExpr expr <*> dsLExprNoLP from dsArithSeq expr (FromTo from to)@@ -891,7 +889,7 @@ Haskell 98 report: -} -dsDo :: [ExprLStmt Id] -> DsM CoreExpr+dsDo :: [ExprLStmt GhcTc] -> DsM CoreExpr dsDo stmts = goL stmts where@@ -926,7 +924,7 @@ let (pats, rhss) = unzip (map (do_arg . snd) args) - do_arg (ApplicativeArgOne pat expr) =+ do_arg (ApplicativeArgOne pat expr _) = (pat, dsLExpr expr) do_arg (ApplicativeArgMany stmts ret pat) = (pat, dsDo (stmts ++ [noLoc $ mkLastStmt (noLoc ret)]))@@ -987,7 +985,7 @@ go _ (ParStmt {}) _ = panic "dsDo ParStmt" go _ (TransStmt {}) _ = panic "dsDo TransStmt" -handle_failure :: LPat Id -> MatchResult -> SyntaxExpr Id -> DsM CoreExpr+handle_failure :: LPat GhcTc -> MatchResult -> SyntaxExpr GhcTc -> DsM CoreExpr -- In a do expression, pattern-match failure just calls -- the monadic 'fail' rather than throwing an exception handle_failure pat match fail_op@@ -1006,14 +1004,31 @@ {- ************************************************************************ * *- Desugaring ConLikes+ Desugaring Variables * * ************************************************************************ -} -dsConLike :: ConLike -> CoreExpr-dsConLike (RealDataCon dc) = Var (dataConWrapId dc)-dsConLike (PatSynCon ps) = case patSynBuilder ps of+dsHsVar :: Bool -- are we directly inside an HsWrap?+ -- See Wrinkle in Note [Detecting forced eta expansion]+ -> Id -> DsM CoreExpr+dsHsVar w var+ | not w+ , let bad_tys = badUseOfLevPolyPrimop var ty+ , not (null bad_tys)+ = do { levPolyPrimopErr var ty bad_tys+ ; return unitExpr } -- return something eminently safe++ | otherwise+ = return (varToCoreExpr var) -- See Note [Desugaring vars]++ where+ ty = idType var++dsConLike :: Bool -- as in dsHsVar+ -> ConLike -> DsM CoreExpr+dsConLike w (RealDataCon dc) = dsHsVar w (dataConWrapId dc)+dsConLike _ (PatSynCon ps) = return $ case patSynBuilder ps of Just (id, add_void) | add_void -> mkCoreApp (text "dsConLike" <+> ppr ps) (Var id) (Var voidPrimId) | otherwise -> Var id@@ -1028,7 +1043,7 @@ -} -- Warn about certain types of values discarded in monadic bindings (#3263)-warnDiscardedDoBindings :: LHsExpr Id -> Type -> DsM ()+warnDiscardedDoBindings :: LHsExpr GhcTc -> Type -> DsM () warnDiscardedDoBindings rhs rhs_ty | Just (m_ty, elt_ty) <- tcSplitAppTy_maybe rhs_ty = do { warn_unused <- woptM Opt_WarnUnusedDoBind@@ -1056,10 +1071,97 @@ | otherwise -- RHS does have type of form (m ty), which is weird = return () -- but at lesat this warning is irrelevant -badMonadBind :: LHsExpr Id -> Type -> SDoc+badMonadBind :: LHsExpr GhcTc -> Type -> SDoc badMonadBind rhs elt_ty = vcat [ hang (text "A do-notation statement discarded a result of type") 2 (quotes (ppr elt_ty)) , hang (text "Suppress this warning by saying") 2 (quotes $ text "_ <-" <+> ppr rhs) ]++{-+************************************************************************+* *+ Forced eta expansion and levity polymorphism+* *+************************************************************************++Note [Detecting forced eta expansion]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We cannot have levity polymorphic function arguments. See+Note [Levity polymorphism invariants] in CoreSyn. But we *can* have+functions that take levity polymorphism arguments, as long as these+functions are eta-reduced. (See #12708 for an example.)++However, we absolutely cannot do this for functions that have no+binding (i.e., say True to Id.hasNoBinding), like primops and unboxed+tuple constructors. These get eta-expanded in CorePrep.maybeSaturate.++Detecting when this is about to happen is a bit tricky, though. When+the desugarer is looking at the Id itself (let's be concrete and+suppose we have (#,#)), we don't know whether it will be levity+polymorphic. So the right spot seems to be to look after the Id has+been applied to its type arguments. To make the algorithm efficient,+it's important to be able to spot ((#,#) @a @b @c @d) without looking+past all the type arguments. We thus require that+ * The body of an HsWrap is not an HsWrap.+With that representation invariant, we simply look inside every HsWrap+to see if its body is an HsVar whose Id hasNoBinding. Then, we look+at the wrapped type. If it has any levity polymorphic arguments, reject.++Interestingly, this approach does not look to see whether the Id in+question will be eta expanded. The logic is this:+ * Either the Id in question is saturated or not.+ * If it is, then it surely can't have levity polymorphic arguments.+ If its wrapped type contains levity polymorphic arguments, reject.+ * If it's not, then it can't be eta expanded with levity polymorphic+ argument. If its wrapped type contains levity polymorphic arguments, reject.+So, either way, we're good to reject.++Wrinkle+~~~~~~~+Not all polymorphic Ids are wrapped in+HsWrap, due to the lazy instantiation of TypeApplications. (See "Visible type+application", ESOP '16.) But if we spot a levity-polymorphic hasNoBinding Id+without a wrapper, then that is surely problem and we can reject.++We thus have a parameter to `dsExpr` that tracks whether or not we are+directly in an HsWrap. If we find a levity-polymorphic hasNoBinding Id when+we're not directly in an HsWrap, reject.++-}++-- | Takes an expression and its instantiated type. If the expression is an+-- HsVar with a hasNoBinding primop and the type has levity-polymorphic arguments,+-- issue an error. See Note [Detecting forced eta expansion]+checkForcedEtaExpansion :: HsExpr GhcTc -> Type -> DsM ()+checkForcedEtaExpansion expr ty+ | Just var <- case expr of+ HsVar (L _ var) -> Just var+ HsConLikeOut (RealDataCon dc) -> Just (dataConWrapId dc)+ _ -> Nothing+ , let bad_tys = badUseOfLevPolyPrimop var ty+ , not (null bad_tys)+ = levPolyPrimopErr var ty bad_tys+checkForcedEtaExpansion _ _ = return ()++-- | Is this a hasNoBinding Id with a levity-polymorphic type?+-- Returns the arguments that are levity polymorphic if they are bad;+-- or an empty list otherwise+-- See Note [Detecting forced eta expansion]+badUseOfLevPolyPrimop :: Id -> Type -> [Type]+badUseOfLevPolyPrimop id ty+ | hasNoBinding id+ = filter isTypeLevPoly arg_tys+ | otherwise+ = []+ where+ (binders, _) = splitPiTys ty+ arg_tys = mapMaybe binderRelevantType_maybe binders++levPolyPrimopErr :: Id -> Type -> [Type] -> DsM ()+levPolyPrimopErr primop ty bad_tys+ = errDs $ vcat [ hang (text "Cannot use primitive with levity-polymorphic arguments:")+ 2 (ppr primop <+> dcolon <+> ppr ty)+ , hang (text "Levity-polymorphic arguments:")+ 2 (vcat (map (\t -> ppr t <+> dcolon <+> ppr (typeKind t)) bad_tys)) ]
deSugar/DsExpr.hs-boot view
@@ -1,10 +1,10 @@ module DsExpr where-import HsSyn ( HsExpr, LHsExpr, LHsLocalBinds, SyntaxExpr )-import Var ( Id )-import DsMonad ( DsM )-import CoreSyn ( CoreExpr )+import HsSyn ( HsExpr, LHsExpr, LHsLocalBinds, SyntaxExpr )+import DsMonad ( DsM )+import CoreSyn ( CoreExpr )+import HsExtension ( GhcTc) -dsExpr :: HsExpr Id -> DsM CoreExpr-dsLExpr, dsLExprNoLP :: LHsExpr Id -> DsM CoreExpr-dsSyntaxExpr :: SyntaxExpr Id -> [CoreExpr] -> DsM CoreExpr-dsLocalBinds :: LHsLocalBinds Id -> CoreExpr -> DsM CoreExpr+dsExpr :: HsExpr GhcTc -> DsM CoreExpr+dsLExpr, dsLExprNoLP :: LHsExpr GhcTc -> DsM CoreExpr+dsSyntaxExpr :: SyntaxExpr GhcTc -> [CoreExpr] -> DsM CoreExpr+dsLocalBinds :: LHsLocalBinds GhcTc -> CoreExpr -> DsM CoreExpr
deSugar/DsForeign.hs view
@@ -7,10 +7,14 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-} module DsForeign ( dsForeigns ) where #include "HsVersions.h"+import GhcPrelude+ import TcRnMonad -- temp import CoreSyn@@ -70,14 +74,14 @@ so we reuse the desugaring code in @DsCCall@ to deal with these. -} -type Binding = (Id, CoreExpr) -- No rec/nonrec structure;- -- the occurrence analyser will sort it all out+type Binding = (Id, CoreExpr) -- No rec/nonrec structure;+ -- the occurrence analyser will sort it all out -dsForeigns :: [LForeignDecl Id]+dsForeigns :: [LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList Binding) dsForeigns fos = getHooked dsForeignsHook dsForeigns' >>= ($ fos) -dsForeigns' :: [LForeignDecl Id]+dsForeigns' :: [LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList Binding) dsForeigns' [] = return (NoStubs, nilOL)
deSugar/DsGRHSs.hs view
@@ -12,13 +12,14 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} DsExpr ( dsLExpr, dsLocalBinds ) import {-# SOURCE #-} Match ( matchSinglePat ) import HsSyn import MkCore import CoreSyn-import Var import DsMonad import DsUtils@@ -44,20 +45,20 @@ necessary. The type argument gives the type of the @ei@. -} -dsGuarded :: GRHSs Id (LHsExpr Id) -> Type -> DsM CoreExpr+dsGuarded :: GRHSs GhcTc (LHsExpr GhcTc) -> Type -> DsM CoreExpr dsGuarded grhss rhs_ty = do- match_result <- dsGRHSs PatBindRhs [] grhss rhs_ty+ match_result <- dsGRHSs PatBindRhs grhss rhs_ty error_expr <- mkErrorAppDs nON_EXHAUSTIVE_GUARDS_ERROR_ID rhs_ty empty extractMatchResult match_result error_expr -- In contrast, @dsGRHSs@ produces a @MatchResult@. -dsGRHSs :: HsMatchContext Name -> [Pat Id] -- These are to build a MatchContext from- -> GRHSs Id (LHsExpr Id) -- Guarded RHSs+dsGRHSs :: HsMatchContext Name+ -> GRHSs GhcTc (LHsExpr GhcTc) -- Guarded RHSs -> Type -- Type of RHS -> DsM MatchResult-dsGRHSs hs_ctx _ (GRHSs grhss binds) rhs_ty+dsGRHSs hs_ctx (GRHSs grhss binds) rhs_ty = ASSERT( notNull grhss ) do { match_results <- mapM (dsGRHS hs_ctx rhs_ty) grhss ; let match_result1 = foldr1 combineMatchResults match_results@@ -65,7 +66,8 @@ -- NB: nested dsLet inside matchResult ; return match_result2 } -dsGRHS :: HsMatchContext Name -> Type -> LGRHS Id (LHsExpr Id) -> DsM MatchResult+dsGRHS :: HsMatchContext Name -> Type -> LGRHS GhcTc (LHsExpr GhcTc)+ -> DsM MatchResult dsGRHS hs_ctx rhs_ty (L _ (GRHS guards rhs)) = matchGuards (map unLoc guards) (PatGuard hs_ctx) rhs rhs_ty @@ -77,10 +79,10 @@ ************************************************************************ -} -matchGuards :: [GuardStmt Id] -- Guard- -> HsStmtContext Name -- Context- -> LHsExpr Id -- RHS- -> Type -- Type of RHS of guard+matchGuards :: [GuardStmt GhcTc] -- Guard+ -> HsStmtContext Name -- Context+ -> LHsExpr GhcTc -- RHS+ -> Type -- Type of RHS of guard -> DsM MatchResult -- See comments with HsExpr.Stmt re what a BodyStmt means@@ -126,7 +128,7 @@ matchGuards (ApplicativeStmt {} : _) _ _ _ = panic "matchGuards ApplicativeLastStmt" -isTrueLHsExpr :: LHsExpr Id -> Maybe (CoreExpr -> DsM CoreExpr)+isTrueLHsExpr :: LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr) -- Returns Just {..} if we're sure that the expression is True -- I.e. * 'True' datacon
deSugar/DsListComp.hs view
@@ -7,11 +7,14 @@ -} {-# LANGUAGE CPP, NamedFieldPuns #-}+{-# LANGUAGE TypeFamilies #-} module DsListComp ( dsListComp, dsPArrComp, dsMonadComp ) where #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} DsExpr ( dsExpr, dsLExpr, dsLExprNoLP, dsLocalBinds, dsSyntaxExpr ) import HsSyn@@ -43,7 +46,7 @@ There will be at least one ``qualifier'' in the input. -} -dsListComp :: [ExprLStmt Id]+dsListComp :: [ExprLStmt GhcTc] -> Type -- Type of entire list -> DsM CoreExpr dsListComp lquals res_ty = do@@ -78,7 +81,7 @@ -- This function lets you desugar a inner list comprehension and a list of the binders -- of that comprehension that we need in the outer comprehension into such an expression -- and the type of the elements that it outputs (tuples of binders)-dsInnerListComp :: (ParStmtBlock Id Id) -> DsM (CoreExpr, Type)+dsInnerListComp :: (ParStmtBlock GhcTc GhcTc) -> DsM (CoreExpr, Type) dsInnerListComp (ParStmtBlock stmts bndrs _) = do { let bndrs_tuple_type = mkBigCoreVarTupTy bndrs list_ty = mkListTy bndrs_tuple_type@@ -91,7 +94,7 @@ -- This function factors out commonality between the desugaring strategies for GroupStmt. -- Given such a statement it gives you back an expression representing how to compute the transformed -- list and the tuple that you need to bind from that list in order to proceed with your desugaring-dsTransStmt :: ExprStmt Id -> DsM (CoreExpr, LPat Id)+dsTransStmt :: ExprStmt GhcTc -> DsM (CoreExpr, LPat GhcTc) dsTransStmt (TransStmt { trS_form = form, trS_stmts = stmts, trS_bndrs = binderMap , trS_by = by, trS_using = using }) = do let (from_bndrs, to_bndrs) = unzip binderMap@@ -211,7 +214,7 @@ with the Unboxed variety. -} -deListComp :: [ExprStmt Id] -> CoreExpr -> DsM CoreExpr+deListComp :: [ExprStmt GhcTc] -> CoreExpr -> DsM CoreExpr deListComp [] _ = panic "deListComp" @@ -261,9 +264,9 @@ deListComp (ApplicativeStmt {} : _) _ = panic "deListComp ApplicativeStmt" -deBindComp :: OutPat Id+deBindComp :: OutPat GhcTc -> CoreExpr- -> [ExprStmt Id]+ -> [ExprStmt GhcTc] -> CoreExpr -> DsM (Expr Id) deBindComp pat core_list1 quals core_list2 = do@@ -317,8 +320,8 @@ \end{verbatim} -} -dfListComp :: Id -> Id -- 'c' and 'n'- -> [ExprStmt Id] -- the rest of the qual's+dfListComp :: Id -> Id -- 'c' and 'n'+ -> [ExprStmt GhcTc] -- the rest of the qual's -> DsM CoreExpr dfListComp _ _ [] = panic "dfListComp"@@ -356,9 +359,9 @@ dfListComp _ _ (ApplicativeStmt {} : _) = panic "dfListComp ApplicativeStmt" -dfBindComp :: Id -> Id -- 'c' and 'n'- -> (LPat Id, CoreExpr)- -> [ExprStmt Id] -- the rest of the qual's+dfBindComp :: Id -> Id -- 'c' and 'n'+ -> (LPat GhcTc, CoreExpr)+ -> [ExprStmt GhcTc] -- the rest of the qual's -> DsM CoreExpr dfBindComp c_id n_id (pat, core_list1) quals = do -- find the required type@@ -478,7 +481,7 @@ -- -- [:e | qss:] = <<[:e | qss:]>> () [:():] ---dsPArrComp :: [ExprStmt Id]+dsPArrComp :: [ExprStmt GhcTc] -> DsM CoreExpr -- Special case for parallel comprehension@@ -514,8 +517,8 @@ -- the work horse ---dePArrComp :: [ExprStmt Id]- -> LPat Id -- the current generator pattern+dePArrComp :: [ExprStmt GhcTc]+ -> LPat GhcTc -- the current generator pattern -> CoreExpr -- the current generator expression -> DsM CoreExpr @@ -612,7 +615,7 @@ -- where -- {x_1, ..., x_n} = DV (qs) ---dePArrParComp :: [ParStmtBlock Id Id] -> [ExprStmt Id] -> DsM CoreExpr+dePArrParComp :: [ParStmtBlock GhcTc GhcTc] -> [ExprStmt GhcTc] -> DsM CoreExpr dePArrParComp qss quals = do (pQss, ceQss) <- deParStmt qss dePArrComp quals pQss ceQss@@ -639,8 +642,8 @@ -- generate Core corresponding to `\p -> e' -- deLambda :: Type -- type of the argument (not levity-polymorphic)- -> LPat Id -- argument pattern- -> LHsExpr Id -- body+ -> LPat GhcTc -- argument pattern+ -> LHsExpr GhcTc -- body -> DsM (CoreExpr, Type) deLambda ty p e = mkLambda ty p =<< dsLExpr e@@ -648,7 +651,7 @@ -- generate Core for a lambda pattern match, where the body is already in Core -- mkLambda :: Type -- type of the argument (not levity-polymorphic)- -> LPat Id -- argument pattern+ -> LPat GhcTc -- argument pattern -> CoreExpr -- desugared body -> DsM (CoreExpr, Type) mkLambda ty p ce = do@@ -672,15 +675,15 @@ -- Translation for monad comprehensions -- Entry point for monad comprehension desugaring-dsMonadComp :: [ExprLStmt Id] -> DsM CoreExpr+dsMonadComp :: [ExprLStmt GhcTc] -> DsM CoreExpr dsMonadComp stmts = dsMcStmts stmts -dsMcStmts :: [ExprLStmt Id] -> DsM CoreExpr+dsMcStmts :: [ExprLStmt GhcTc] -> DsM CoreExpr dsMcStmts [] = panic "dsMcStmts" dsMcStmts (L loc stmt : lstmts) = putSrcSpanDs loc (dsMcStmt stmt lstmts) ----------------dsMcStmt :: ExprStmt Id -> [ExprLStmt Id] -> DsM CoreExpr+dsMcStmt :: ExprStmt GhcTc -> [ExprLStmt GhcTc] -> DsM CoreExpr dsMcStmt (LastStmt body _ ret_op) stmts = ASSERT( null stmts )@@ -803,12 +806,12 @@ -- general `rhs' >>= \pat -> stmts` desugaring where `rhs'` is already a -- desugared `CoreExpr`-dsMcBindStmt :: LPat Id+dsMcBindStmt :: LPat GhcTc -> CoreExpr -- ^ the desugared rhs of the bind statement- -> SyntaxExpr Id- -> SyntaxExpr Id+ -> SyntaxExpr GhcTc+ -> SyntaxExpr GhcTc -> Type -- ^ S in (>>=) :: Q -> (R -> S) -> T- -> [ExprLStmt Id]+ -> [ExprLStmt GhcTc] -> DsM CoreExpr dsMcBindStmt pat rhs' bind_op fail_op res1_ty stmts = do { body <- dsMcStmts stmts@@ -840,9 +843,9 @@ -- returns the desugaring of -- [ (a,b,c) | quals ] -dsInnerMonadComp :: [ExprLStmt Id]- -> [Id] -- Return a tuple of these variables- -> SyntaxExpr Id -- The monomorphic "return" operator+dsInnerMonadComp :: [ExprLStmt GhcTc]+ -> [Id] -- Return a tuple of these variables+ -> SyntaxExpr GhcTc -- The monomorphic "return" operator -> DsM CoreExpr dsInnerMonadComp stmts bndrs ret_op = dsMcStmts (stmts ++ [noLoc (LastStmt (mkBigLHsVarTupId bndrs) False ret_op)])@@ -860,7 +863,7 @@ -- , fmap (selN2 :: (t1, t2) -> t2) ys ) mkMcUnzipM :: TransForm- -> HsExpr TcId -- fmap+ -> HsExpr GhcTcId -- fmap -> Id -- Of type n (a,b,c) -> [Type] -- [a,b,c] (not levity-polymorphic) -> DsM CoreExpr -- Of type (n a, n b, n c)
deSugar/DsMeta.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE CPP, TypeFamilies #-}+{-# LANGUAGE FlexibleContexts #-} ----------------------------------------------------------------------------- --@@ -19,6 +20,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} DsExpr ( dsExpr ) import MatchLit@@ -64,7 +67,7 @@ import Data.List ------------------------------------------------------------------------------dsBracket :: HsBracket Name -> [PendingTcSplice] -> DsM CoreExpr+dsBracket :: HsBracket GhcRn -> [PendingTcSplice] -> DsM CoreExpr -- Returns a CoreExpr of type TH.ExpQ -- The quoted thing is parameterised over Name, even though it has -- been type checked. We don't want all those type decorations!@@ -101,12 +104,12 @@ -- Declarations ------------------------------------------------------- -repTopP :: LPat Name -> DsM (Core TH.PatQ)+repTopP :: LPat GhcRn -> DsM (Core TH.PatQ) repTopP pat = do { ss <- mkGenSyms (collectPatBinders pat) ; pat' <- addBinds ss (repLP pat) ; wrapGenSyms ss pat' } -repTopDs :: HsGroup Name -> DsM (Core (TH.Q [TH.Dec]))+repTopDs :: HsGroup GhcRn -> DsM (Core (TH.Q [TH.Dec])) repTopDs group@(HsGroup { hs_valds = valds , hs_splcds = splcds , hs_tyclds = tyclds@@ -178,12 +181,12 @@ no_doc (L loc _) = notHandledL loc "Haddock documentation" empty -hsSigTvBinders :: HsValBinds Name -> [Name]+hsSigTvBinders :: HsValBinds GhcRn -> [Name] -- See Note [Scoped type variables in bindings] hsSigTvBinders binds = concatMap get_scoped_tvs sigs where- get_scoped_tvs :: LSig Name -> [Name]+ get_scoped_tvs :: LSig GhcRn -> [Name] -- Both implicit and explicit quantified variables -- We need the implicit ones for f :: forall (a::k). blah -- here 'k' scopes too@@ -262,7 +265,7 @@ -- represent associated family instances ---repTyClD :: LTyClDecl Name -> DsM (Maybe (SrcSpan, Core TH.DecQ))+repTyClD :: LTyClDecl GhcRn -> DsM (Maybe (SrcSpan, Core TH.DecQ)) repTyClD (L loc (FamDecl { tcdFam = fam })) = liftM Just $ repFamilyDecl (L loc fam) @@ -297,7 +300,7 @@ } --------------------------repRoleD :: LRoleAnnotDecl Name -> DsM (SrcSpan, Core TH.DecQ)+repRoleD :: LRoleAnnotDecl GhcRn -> DsM (SrcSpan, Core TH.DecQ) repRoleD (L loc (RoleAnnotDecl tycon roles)) = do { tycon1 <- lookupLOcc tycon ; roles1 <- mapM repRole roles@@ -306,9 +309,9 @@ ; return (loc, dec) } --------------------------repDataDefn :: Core TH.Name -> Core [TH.TyVarBndr]+repDataDefn :: Core TH.Name -> Core [TH.TyVarBndrQ] -> Maybe (Core [TH.TypeQ])- -> HsDataDefn Name+ -> HsDataDefn GhcRn -> DsM (Core TH.DecQ) repDataDefn tc bndrs opt_tys (HsDataDefn { dd_ND = new_or_data, dd_ctxt = cxt, dd_kindSig = ksig@@ -317,34 +320,34 @@ ; derivs1 <- repDerivs mb_derivs ; case (new_or_data, cons) of (NewType, [con]) -> do { con' <- repC con- ; ksig' <- repMaybeLKind ksig+ ; ksig' <- repMaybeLTy ksig ; repNewtype cxt1 tc bndrs opt_tys ksig' con' derivs1 } (NewType, _) -> failWithDs (text "Multiple constructors for newtype:" <+> pprQuotedList (getConNames $ unLoc $ head cons))- (DataType, _) -> do { ksig' <- repMaybeLKind ksig+ (DataType, _) -> do { ksig' <- repMaybeLTy ksig ; consL <- mapM repC cons ; cons1 <- coreList conQTyConName consL ; repData cxt1 tc bndrs opt_tys ksig' cons1 derivs1 } } -repSynDecl :: Core TH.Name -> Core [TH.TyVarBndr]- -> LHsType Name+repSynDecl :: Core TH.Name -> Core [TH.TyVarBndrQ]+ -> LHsType GhcRn -> DsM (Core TH.DecQ) repSynDecl tc bndrs ty = do { ty1 <- repLTy ty ; repTySyn tc bndrs ty1 } -repFamilyDecl :: LFamilyDecl Name -> DsM (SrcSpan, Core TH.DecQ)+repFamilyDecl :: LFamilyDecl GhcRn -> DsM (SrcSpan, Core TH.DecQ) repFamilyDecl decl@(L loc (FamilyDecl { fdInfo = info, fdLName = tc, fdTyVars = tvs, fdResultSig = L _ resultSig, fdInjectivityAnn = injectivity })) = do { tc1 <- lookupLOcc tc -- See note [Binders and occurrences]- ; let mkHsQTvs :: [LHsTyVarBndr Name] -> LHsQTyVars Name+ ; let mkHsQTvs :: [LHsTyVarBndr GhcRn] -> LHsQTyVars GhcRn mkHsQTvs tvs = HsQTvs { hsq_implicit = [], hsq_explicit = tvs , hsq_dependent = emptyNameSet } resTyVar = case resultSig of@@ -356,7 +359,7 @@ ClosedTypeFamily Nothing -> notHandled "abstract closed type family" (ppr decl) ClosedTypeFamily (Just eqns) ->- do { eqns1 <- mapM repTyFamEqn eqns+ do { eqns1 <- mapM (repTyFamEqn . unLoc) eqns ; eqns2 <- coreList tySynEqnQTyConName eqns1 ; result <- repFamilyResultSig resultSig ; inj <- repInjectivityAnn injectivity@@ -372,9 +375,9 @@ } -- | Represent result signature of a type family-repFamilyResultSig :: FamilyResultSig Name -> DsM (Core TH.FamilyResultSig)+repFamilyResultSig :: FamilyResultSig GhcRn -> DsM (Core TH.FamilyResultSigQ) repFamilyResultSig NoSig = repNoSig-repFamilyResultSig (KindSig ki) = do { ki' <- repLKind ki+repFamilyResultSig (KindSig ki) = do { ki' <- repLTy ki ; repKindSig ki' } repFamilyResultSig (TyVarSig bndr) = do { bndr' <- repTyVarBndr bndr ; repTyVarSig bndr' }@@ -382,17 +385,17 @@ -- | Represent result signature using a Maybe Kind. Used with data families, -- where the result signature can be either missing or a kind but never a named -- result variable.-repFamilyResultSigToMaybeKind :: FamilyResultSig Name- -> DsM (Core (Maybe TH.Kind))+repFamilyResultSigToMaybeKind :: FamilyResultSig GhcRn+ -> DsM (Core (Maybe TH.KindQ)) repFamilyResultSigToMaybeKind NoSig =- do { coreNothing kindTyConName }+ do { coreNothing kindQTyConName } repFamilyResultSigToMaybeKind (KindSig ki) =- do { ki' <- repLKind ki- ; coreJust kindTyConName ki' }+ do { ki' <- repLTy ki+ ; coreJust kindQTyConName ki' } repFamilyResultSigToMaybeKind _ = panic "repFamilyResultSigToMaybeKind" -- | Represent injectivity annotation of a type family-repInjectivityAnn :: Maybe (LInjectivityAnn Name)+repInjectivityAnn :: Maybe (LInjectivityAnn GhcRn) -> DsM (Core (Maybe TH.InjectivityAnn)) repInjectivityAnn Nothing = do { coreNothing injAnnTyConName }@@ -403,17 +406,17 @@ ; injAnn <- rep2 injectivityAnnName [unC lhs', unC rhs2] ; coreJust injAnnTyConName injAnn } -repFamilyDecls :: [LFamilyDecl Name] -> DsM [Core TH.DecQ]+repFamilyDecls :: [LFamilyDecl GhcRn] -> DsM [Core TH.DecQ] repFamilyDecls fds = liftM de_loc (mapM repFamilyDecl fds) -repAssocTyFamDefaults :: [LTyFamDefltEqn Name] -> DsM [Core TH.DecQ]+repAssocTyFamDefaults :: [LTyFamDefltEqn GhcRn] -> DsM [Core TH.DecQ] repAssocTyFamDefaults = mapM rep_deflt where -- very like repTyFamEqn, but different in the details- rep_deflt :: LTyFamDefltEqn Name -> DsM (Core TH.DecQ)- rep_deflt (L _ (TyFamEqn { tfe_tycon = tc- , tfe_pats = bndrs- , tfe_rhs = rhs }))+ rep_deflt :: LTyFamDefltEqn GhcRn -> DsM (Core TH.DecQ)+ rep_deflt (L _ (FamEqn { feqn_tycon = tc+ , feqn_pats = bndrs+ , feqn_rhs = rhs })) = addTyClTyVarBinds bndrs $ \ _ -> do { tc1 <- lookupLOcc tc ; tys1 <- repLTys (hsLTyVarBndrsToTypes bndrs)@@ -436,7 +439,7 @@ -- Represent instance declarations ---repInstD :: LInstDecl Name -> DsM (SrcSpan, Core TH.DecQ)+repInstD :: LInstDecl GhcRn -> DsM (SrcSpan, Core TH.DecQ) repInstD (L loc (TyFamInstD { tfid_inst = fi_decl })) = do { dec <- repTyFamInstD fi_decl ; return (loc, dec) }@@ -447,7 +450,7 @@ = do { dec <- repClsInstD cls_decl ; return (loc, dec) } -repClsInstD :: ClsInstDecl Name -> DsM (Core TH.DecQ)+repClsInstD :: ClsInstDecl GhcRn -> DsM (Core TH.DecQ) repClsInstD (ClsInstDecl { cid_poly_ty = ty, cid_binds = binds , cid_sigs = prags, cid_tyfam_insts = ats , cid_datafam_insts = adts@@ -475,7 +478,7 @@ where (tvs, cxt, inst_ty) = splitLHsInstDeclTy ty -repStandaloneDerivD :: LDerivDecl Name -> DsM (SrcSpan, Core TH.DecQ)+repStandaloneDerivD :: LDerivDecl GhcRn -> DsM (SrcSpan, Core TH.DecQ) repStandaloneDerivD (L loc (DerivDecl { deriv_strategy = strat , deriv_type = ty })) = do { dec <- addSimpleTyVarBinds tvs $@@ -487,17 +490,17 @@ where (tvs, cxt, inst_ty) = splitLHsInstDeclTy ty -repTyFamInstD :: TyFamInstDecl Name -> DsM (Core TH.DecQ)+repTyFamInstD :: TyFamInstDecl GhcRn -> DsM (Core TH.DecQ) repTyFamInstD decl@(TyFamInstDecl { tfid_eqn = eqn }) = do { let tc_name = tyFamInstDeclLName decl ; tc <- lookupLOcc tc_name -- See note [Binders and occurrences] ; eqn1 <- repTyFamEqn eqn ; repTySynInst tc eqn1 } -repTyFamEqn :: LTyFamInstEqn Name -> DsM (Core TH.TySynEqnQ)-repTyFamEqn (L _ (TyFamEqn { tfe_pats = HsIB { hsib_body = tys- , hsib_vars = var_names }- , tfe_rhs = rhs }))+repTyFamEqn :: TyFamInstEqn GhcRn -> DsM (Core TH.TySynEqnQ)+repTyFamEqn (HsIB { hsib_vars = var_names+ , hsib_body = FamEqn { feqn_pats = tys+ , feqn_rhs = rhs }}) = do { let hs_tvs = HsQTvs { hsq_implicit = var_names , hsq_explicit = [] , hsq_dependent = emptyNameSet } -- Yuk@@ -507,10 +510,12 @@ ; rhs1 <- repLTy rhs ; repTySynEqn tys2 rhs1 } } -repDataFamInstD :: DataFamInstDecl Name -> DsM (Core TH.DecQ)-repDataFamInstD (DataFamInstDecl { dfid_tycon = tc_name- , dfid_pats = HsIB { hsib_body = tys, hsib_vars = var_names }- , dfid_defn = defn })+repDataFamInstD :: DataFamInstDecl GhcRn -> DsM (Core TH.DecQ)+repDataFamInstD (DataFamInstDecl { dfid_eqn =+ (HsIB { hsib_vars = var_names+ , hsib_body = FamEqn { feqn_tycon = tc_name+ , feqn_pats = tys+ , feqn_rhs = defn }})}) = do { tc <- lookupLOcc tc_name -- See note [Binders and occurrences] ; let hs_tvs = HsQTvs { hsq_implicit = var_names , hsq_explicit = []@@ -519,7 +524,7 @@ do { tys1 <- repList typeQTyConName repLTy tys ; repDataDefn tc bndrs (Just tys1) defn } } -repForD :: Located (ForeignDecl Name) -> DsM (SrcSpan, Core TH.DecQ)+repForD :: Located (ForeignDecl GhcRn) -> DsM (SrcSpan, Core TH.DecQ) repForD (L loc (ForeignImport { fd_name = name, fd_sig_ty = typ , fd_fi = CImport (L _ cc) (L _ s) mch cis _ })) = do MkC name' <- lookupLOcc name@@ -560,7 +565,7 @@ repSafety PlayInterruptible = rep2 interruptibleName [] repSafety PlaySafe = rep2 safeName [] -repFixD :: LFixitySig Name -> DsM [(SrcSpan, Core TH.DecQ)]+repFixD :: LFixitySig GhcRn -> DsM [(SrcSpan, Core TH.DecQ)] repFixD (L loc (FixitySig names (Fixity _ prec dir))) = do { MkC prec' <- coreIntLit prec ; let rep_fn = case dir of@@ -573,7 +578,7 @@ ; return (loc,dec) } ; mapM do_one names } -repRuleD :: LRuleDecl Name -> DsM (SrcSpan, Core TH.DecQ)+repRuleD :: LRuleDecl GhcRn -> DsM (SrcSpan, Core TH.DecQ) repRuleD (L loc (HsRule n act bndrs lhs _ rhs _)) = do { let bndr_names = concatMap ruleBndrNames bndrs ; ss <- mkGenSyms bndr_names@@ -587,13 +592,13 @@ ; rule2 <- wrapGenSyms ss rule1 ; return (loc, rule2) } -ruleBndrNames :: LRuleBndr Name -> [Name]+ruleBndrNames :: LRuleBndr GhcRn -> [Name] ruleBndrNames (L _ (RuleBndr n)) = [unLoc n] ruleBndrNames (L _ (RuleBndrSig n sig)) | HsWC { hswc_body = HsIB { hsib_vars = vars }} <- sig = unLoc n : vars -repRuleBndr :: LRuleBndr Name -> DsM (Core TH.RuleBndrQ)+repRuleBndr :: LRuleBndr GhcRn -> DsM (Core TH.RuleBndrQ) repRuleBndr (L _ (RuleBndr n)) = do { MkC n' <- lookupLBinder n ; rep2 ruleVarName [n'] }@@ -602,7 +607,7 @@ ; MkC ty' <- repLTy (hsSigWcType sig) ; rep2 typedRuleVarName [n', ty'] } -repAnnD :: LAnnDecl Name -> DsM (SrcSpan, Core TH.DecQ)+repAnnD :: LAnnDecl GhcRn -> DsM (SrcSpan, Core TH.DecQ) repAnnD (L loc (HsAnnotation _ ann_prov (L _ exp))) = do { target <- repAnnProv ann_prov ; exp' <- repE exp@@ -623,7 +628,7 @@ -- Constructors ------------------------------------------------------- -repC :: LConDecl Name -> DsM (Core TH.ConQ)+repC :: LConDecl GhcRn -> DsM (Core TH.ConQ) repC (L _ (ConDeclH98 { con_name = con , con_qvars = Nothing, con_cxt = Nothing , con_details = details }))@@ -681,7 +686,7 @@ repSrcStrictness SrcStrict = rep2 sourceStrictName [] repSrcStrictness NoSrcStrict = rep2 noSourceStrictnessName [] -repBangTy :: LBangType Name -> DsM (Core (TH.BangTypeQ))+repBangTy :: LBangType GhcRn -> DsM (Core (TH.BangTypeQ)) repBangTy ty = do MkC u <- repSrcUnpackedness su' MkC s <- repSrcStrictness ss'@@ -697,10 +702,10 @@ -- Deriving clauses ------------------------------------------------------- -repDerivs :: HsDeriving Name -> DsM (Core [TH.DerivClauseQ])+repDerivs :: HsDeriving GhcRn -> DsM (Core [TH.DerivClauseQ]) repDerivs (L _ clauses) = repList derivClauseQTyConName repDerivClause clauses -repDerivClause :: LHsDerivingClause Name+repDerivClause :: LHsDerivingClause GhcRn -> DsM (Core TH.DerivClauseQ) repDerivClause (L _ (HsDerivingClause { deriv_clause_strategy = dcs , deriv_clause_tys = L _ dct }))@@ -708,22 +713,22 @@ MkC dct' <- repList typeQTyConName (rep_deriv_ty . hsSigType) dct rep2 derivClauseName [dcs',dct'] where- rep_deriv_ty :: LHsType Name -> DsM (Core TH.TypeQ)+ rep_deriv_ty :: LHsType GhcRn -> DsM (Core TH.TypeQ) rep_deriv_ty (L _ ty) = repTy ty ------------------------------------------------------- -- Signatures in a class decl, or a group of bindings ------------------------------------------------------- -rep_sigs :: [LSig Name] -> DsM [Core TH.DecQ]+rep_sigs :: [LSig GhcRn] -> DsM [Core TH.DecQ] rep_sigs sigs = do locs_cores <- rep_sigs' sigs return $ de_loc $ sort_by_loc locs_cores -rep_sigs' :: [LSig Name] -> DsM [(SrcSpan, Core TH.DecQ)]+rep_sigs' :: [LSig GhcRn] -> DsM [(SrcSpan, Core TH.DecQ)] -- We silently ignore ones we don't recognise rep_sigs' = concatMapM rep_sig -rep_sig :: LSig Name -> DsM [(SrcSpan, Core TH.DecQ)]+rep_sig :: LSig GhcRn -> DsM [(SrcSpan, Core TH.DecQ)] rep_sig (L loc (TypeSig nms ty)) = mapM (rep_wc_ty_sig sigDName loc ty) nms rep_sig (L loc (PatSynSig nms ty)) = mapM (rep_patsyn_ty_sig loc ty) nms rep_sig (L loc (ClassOpSig is_deflt nms ty))@@ -740,7 +745,7 @@ rep_sig (L loc (CompleteMatchSig _st cls mty)) = rep_complete_sig cls mty loc -rep_ty_sig :: Name -> SrcSpan -> LHsSigType Name -> Located Name+rep_ty_sig :: Name -> SrcSpan -> LHsSigType GhcRn -> Located Name -> DsM (SrcSpan, Core TH.DecQ) rep_ty_sig mk_sig loc sig_ty nm = do { nm1 <- lookupLOcc nm@@ -748,7 +753,7 @@ ; sig <- repProto mk_sig nm1 ty1 ; return (loc, sig) } -rep_patsyn_ty_sig :: SrcSpan -> LHsSigType Name -> Located Name+rep_patsyn_ty_sig :: SrcSpan -> LHsSigType GhcRn -> Located Name -> DsM (SrcSpan, Core TH.DecQ) -- represents a pattern synonym type signature; -- see Note [Pattern synonym type signatures and Template Haskell] in Convert@@ -758,7 +763,7 @@ ; sig <- repProto patSynSigDName nm1 ty1 ; return (loc, sig) } -rep_wc_ty_sig :: Name -> SrcSpan -> LHsSigWcType Name -> Located Name+rep_wc_ty_sig :: Name -> SrcSpan -> LHsSigWcType GhcRn -> Located Name -> DsM (SrcSpan, Core TH.DecQ) -- We must special-case the top-level explicit for-all of a TypeSig -- See Note [Scoped type variables in bindings]@@ -768,7 +773,7 @@ = do { nm1 <- lookupLOcc nm ; let rep_in_scope_tv tv = do { name <- lookupBinder (hsLTyVarName tv) ; repTyVarBndrWithKind tv name }- ; th_explicit_tvs <- repList tyVarBndrTyConName rep_in_scope_tv+ ; th_explicit_tvs <- repList tyVarBndrQTyConName rep_in_scope_tv explicit_tvs -- NB: Don't pass any implicit type variables to repList above -- See Note [Don't quantify implicit type variables in quotes]@@ -794,14 +799,15 @@ ; return [(loc, pragma)] } -rep_specialise :: Located Name -> LHsSigType Name -> InlinePragma -> SrcSpan+rep_specialise :: Located Name -> LHsSigType GhcRn -> InlinePragma+ -> SrcSpan -> DsM [(SrcSpan, Core TH.DecQ)] rep_specialise nm ty ispec loc = do { nm1 <- lookupLOcc nm ; ty1 <- repHsSigType ty ; phases <- repPhases $ inl_act ispec ; let inline = inl_inline ispec- ; pragma <- if isEmptyInlineSpec inline+ ; pragma <- if noUserInlineSpec inline then -- SPECIALISE repPragSpec nm1 ty1 phases else -- SPECIALISE INLINE@@ -810,7 +816,8 @@ ; return [(loc, pragma)] } -rep_specialiseInst :: LHsSigType Name -> SrcSpan -> DsM [(SrcSpan, Core TH.DecQ)]+rep_specialiseInst :: LHsSigType GhcRn -> SrcSpan+ -> DsM [(SrcSpan, Core TH.DecQ)] rep_specialiseInst ty loc = do { ty1 <- repHsSigType ty ; pragma <- repPragSpecInst ty1@@ -860,8 +867,8 @@ ; term <- addBinds fresh_names thing_inside ; wrapGenSyms fresh_names term } -addTyVarBinds :: LHsQTyVars Name -- the binders to be added- -> (Core [TH.TyVarBndr] -> DsM (Core (TH.Q a))) -- action in the ext env+addTyVarBinds :: LHsQTyVars GhcRn -- the binders to be added+ -> (Core [TH.TyVarBndrQ] -> DsM (Core (TH.Q a))) -- action in the ext env -> DsM (Core (TH.Q a)) -- gensym a list of type variables and enter them into the meta environment; -- the computations passed as the second argument is executed in that extended@@ -872,15 +879,15 @@ ; fresh_exp_names <- mkGenSyms (map hsLTyVarName exp_tvs) ; let fresh_names = fresh_imp_names ++ fresh_exp_names ; term <- addBinds fresh_names $- do { kbs <- repList tyVarBndrTyConName mk_tv_bndr+ do { kbs <- repList tyVarBndrQTyConName mk_tv_bndr (exp_tvs `zip` fresh_exp_names) ; m kbs } ; wrapGenSyms fresh_names term } where mk_tv_bndr (tv, (_,v)) = repTyVarBndrWithKind tv (coreVar v) -addTyClTyVarBinds :: LHsQTyVars Name- -> (Core [TH.TyVarBndr] -> DsM (Core (TH.Q a)))+addTyClTyVarBinds :: LHsQTyVars GhcRn+ -> (Core [TH.TyVarBndrQ] -> DsM (Core (TH.Q a))) -> DsM (Core (TH.Q a)) -- Used for data/newtype declarations, and family instances,@@ -896,41 +903,43 @@ -- This makes things work for family declarations ; term <- addBinds freshNames $- do { kbs <- repList tyVarBndrTyConName mk_tv_bndr (hsQTvExplicit tvs)+ do { kbs <- repList tyVarBndrQTyConName mk_tv_bndr+ (hsQTvExplicit tvs) ; m kbs } ; wrapGenSyms freshNames term } where+ mk_tv_bndr :: LHsTyVarBndr GhcRn -> DsM (Core TH.TyVarBndrQ) mk_tv_bndr tv = do { v <- lookupBinder (hsLTyVarName tv) ; repTyVarBndrWithKind tv v } -- Produce kinded binder constructors from the Haskell tyvar binders ---repTyVarBndrWithKind :: LHsTyVarBndr Name- -> Core TH.Name -> DsM (Core TH.TyVarBndr)+repTyVarBndrWithKind :: LHsTyVarBndr GhcRn+ -> Core TH.Name -> DsM (Core TH.TyVarBndrQ) repTyVarBndrWithKind (L _ (UserTyVar _)) nm = repPlainTV nm repTyVarBndrWithKind (L _ (KindedTyVar _ ki)) nm- = repLKind ki >>= repKindedTV nm+ = repLTy ki >>= repKindedTV nm -- | Represent a type variable binder-repTyVarBndr :: LHsTyVarBndr Name -> DsM (Core TH.TyVarBndr)+repTyVarBndr :: LHsTyVarBndr GhcRn -> DsM (Core TH.TyVarBndrQ) repTyVarBndr (L _ (UserTyVar (L _ nm)) )= do { nm' <- lookupBinder nm ; repPlainTV nm' } repTyVarBndr (L _ (KindedTyVar (L _ nm) ki)) = do { nm' <- lookupBinder nm- ; ki' <- repLKind ki+ ; ki' <- repLTy ki ; repKindedTV nm' ki' } -- represent a type context ---repLContext :: LHsContext Name -> DsM (Core TH.CxtQ)+repLContext :: LHsContext GhcRn -> DsM (Core TH.CxtQ) repLContext (L _ ctxt) = repContext ctxt -repContext :: HsContext Name -> DsM (Core TH.CxtQ)+repContext :: HsContext GhcRn -> DsM (Core TH.CxtQ) repContext ctxt = do preds <- repList typeQTyConName repLTy ctxt repCtxt preds -repHsSigType :: LHsSigType Name -> DsM (Core TH.TypeQ)+repHsSigType :: LHsSigType GhcRn -> DsM (Core TH.TypeQ) repHsSigType (HsIB { hsib_vars = implicit_tvs , hsib_body = body }) | (explicit_tvs, ctxt, ty) <- splitLHsSigmaTy body@@ -946,7 +955,7 @@ then return th_ty else repTForall th_explicit_tvs th_ctxt th_ty } -repHsPatSynSigType :: LHsSigType Name -> DsM (Core TH.TypeQ)+repHsPatSynSigType :: LHsSigType GhcRn -> DsM (Core TH.TypeQ) repHsPatSynSigType (HsIB { hsib_vars = implicit_tvs , hsib_body = body }) = addTyVarBinds (newTvs implicit_tvs univs) $ \th_univs ->@@ -965,19 +974,19 @@ (univs, reqs, exis, provs, ty) = splitLHsPatSynTy body -repHsSigWcType :: LHsSigWcType Name -> DsM (Core TH.TypeQ)+repHsSigWcType :: LHsSigWcType GhcRn -> DsM (Core TH.TypeQ) repHsSigWcType (HsWC { hswc_body = sig1 }) = repHsSigType sig1 -- yield the representation of a list of types-repLTys :: [LHsType Name] -> DsM [Core TH.TypeQ]+repLTys :: [LHsType GhcRn] -> DsM [Core TH.TypeQ] repLTys tys = mapM repLTy tys -- represent a type-repLTy :: LHsType Name -> DsM (Core TH.TypeQ)+repLTy :: LHsType GhcRn -> DsM (Core TH.TypeQ) repLTy (L _ ty) = repTy ty -repForall :: HsType Name -> DsM (Core TH.TypeQ)+repForall :: HsType GhcRn -> DsM (Core TH.TypeQ) -- Arg of repForall is always HsForAllTy or HsQualTy repForall ty | (tvs, ctxt, tau) <- splitLHsSigmaTy (noLoc ty)@@ -987,11 +996,13 @@ ; ty1 <- repLTy tau ; repTForall bndrs ctxt1 ty1 } -repTy :: HsType Name -> DsM (Core TH.TypeQ)+repTy :: HsType GhcRn -> DsM (Core TH.TypeQ) repTy ty@(HsForAllTy {}) = repForall ty repTy ty@(HsQualTy {}) = repForall ty repTy (HsTyVar _ (L _ n))+ | isLiftedTypeKindTyConName n = repTStar+ | n `hasKey` constraintKindTyConKey = repTConstraint | isTvOcc occ = do tv1 <- lookupOcc n repTvar tv1 | isDataOcc occ = do tc1 <- lookupOcc n@@ -1040,7 +1051,7 @@ repTapps eq [t1', t2'] repTy (HsKindSig t k) = do t1 <- repLTy t- k1 <- repLKind k+ k1 <- repLTy k repTSig t1 k1 repTy (HsSpliceTy splice _) = repSplice splice repTy (HsExplicitListTy _ _ tys) = do@@ -1064,49 +1075,14 @@ ; rep2 strTyLitName [s'] } --- represent a kind----repLKind :: LHsKind Name -> DsM (Core TH.Kind)-repLKind ki- = do { let (kis, ki') = splitHsFunType ki- ; kis_rep <- mapM repLKind kis- ; ki'_rep <- repNonArrowLKind ki'- ; kcon <- repKArrow- ; let f k1 k2 = repKApp kcon k1 >>= flip repKApp k2- ; foldrM f ki'_rep kis_rep- }---- | Represent a kind wrapped in a Maybe-repMaybeLKind :: Maybe (LHsKind Name)- -> DsM (Core (Maybe TH.Kind))-repMaybeLKind Nothing =- do { coreNothing kindTyConName }-repMaybeLKind (Just ki) =- do { ki' <- repLKind ki- ; coreJust kindTyConName ki' }--repNonArrowLKind :: LHsKind Name -> DsM (Core TH.Kind)-repNonArrowLKind (L _ ki) = repNonArrowKind ki--repNonArrowKind :: HsKind Name -> DsM (Core TH.Kind)-repNonArrowKind (HsTyVar _ (L _ name))- | isLiftedTypeKindTyConName name = repKStar- | name `hasKey` constraintKindTyConKey = repKConstraint- | isTvOcc (nameOccName name) = lookupOcc name >>= repKVar- | otherwise = lookupOcc name >>= repKCon-repNonArrowKind (HsAppTy f a) = do { f' <- repLKind f- ; a' <- repLKind a- ; repKApp f' a'- }-repNonArrowKind (HsListTy k) = do { k' <- repLKind k- ; kcon <- repKList- ; repKApp kcon k'- }-repNonArrowKind (HsTupleTy _ ks) = do { ks' <- mapM repLKind ks- ; kcon <- repKTuple (length ks)- ; repKApps kcon ks'- }-repNonArrowKind k = notHandled "Exotic form of kind" (ppr k)+-- | Represent a type wrapped in a Maybe+repMaybeLTy :: Maybe (LHsKind GhcRn)+ -> DsM (Core (Maybe TH.TypeQ))+repMaybeLTy Nothing =+ do { coreNothing kindQTyConName }+repMaybeLTy (Just ki) =+ do { ki' <- repLTy ki+ ; coreJust kindQTyConName ki' } repRole :: Located (Maybe Role) -> DsM (Core TH.Role) repRole (L _ (Just Nominal)) = rep2 nominalRName []@@ -1118,7 +1094,7 @@ -- Splices ----------------------------------------------------------------------------- -repSplice :: HsSplice Name -> DsM (Core a)+repSplice :: HsSplice GhcRn -> DsM (Core a) -- See Note [How brackets and nested splices are handled] in TcSplice -- We return a CoreExpr of any old type; the context should know repSplice (HsTypedSplice _ n _) = rep_splice n@@ -1139,16 +1115,16 @@ -- Expressions ----------------------------------------------------------------------------- -repLEs :: [LHsExpr Name] -> DsM (Core [TH.ExpQ])+repLEs :: [LHsExpr GhcRn] -> DsM (Core [TH.ExpQ]) repLEs es = repList expQTyConName repLE es -- FIXME: some of these panics should be converted into proper error messages -- unless we can make sure that constructs, which are plainly not -- supported in TH already lead to error messages at an earlier stage-repLE :: LHsExpr Name -> DsM (Core TH.ExpQ)+repLE :: LHsExpr GhcRn -> DsM (Core TH.ExpQ) repLE (L loc e) = putSrcSpanDs loc (repE e) -repE :: HsExpr Name -> DsM (Core TH.ExpQ)+repE :: HsExpr GhcRn -> DsM (Core TH.ExpQ) repE (HsVar (L _ x)) = do { mb_val <- dsLookupMetaEnv x ; case mb_val of@@ -1158,7 +1134,7 @@ Just (DsSplice e) -> do { e' <- dsExpr e ; return (MkC e') } } repE e@(HsIPVar _) = notHandled "Implicit parameters" (ppr e)-repE e@(HsOverLabel{}) = notHandled "Overloaded labels" (ppr e)+repE (HsOverLabel _ s) = repOverLabel s repE e@(HsRecFld f) = case f of Unambiguous _ x -> repE (HsVar (noLoc x))@@ -1284,8 +1260,8 @@ ----------------------------------------------------------------------------- -- Building representations of auxillary structures like Match, Clause, Stmt, -repMatchTup :: LMatch Name (LHsExpr Name) -> DsM (Core TH.MatchQ)-repMatchTup (L _ (Match _ [p] _ (GRHSs guards (L _ wheres)))) =+repMatchTup :: LMatch GhcRn (LHsExpr GhcRn) -> DsM (Core TH.MatchQ)+repMatchTup (L _ (Match { m_pats = [p], m_grhss = GRHSs guards (L _ wheres) })) = do { ss1 <- mkGenSyms (collectPatBinders p) ; addBinds ss1 $ do { ; p1 <- repLP p@@ -1296,8 +1272,8 @@ ; wrapGenSyms (ss1++ss2) match }}} repMatchTup _ = panic "repMatchTup: case alt with more than one arg" -repClauseTup :: LMatch Name (LHsExpr Name) -> DsM (Core TH.ClauseQ)-repClauseTup (L _ (Match _ ps _ (GRHSs guards (L _ wheres)))) =+repClauseTup :: LMatch GhcRn (LHsExpr GhcRn) -> DsM (Core TH.ClauseQ)+repClauseTup (L _ (Match { m_pats = ps, m_grhss = GRHSs guards (L _ wheres) })) = do { ss1 <- mkGenSyms (collectPatsBinders ps) ; addBinds ss1 $ do { ps1 <- repLPs ps@@ -1307,7 +1283,7 @@ ; clause <- repClause ps1 gs ds ; wrapGenSyms (ss1++ss2) clause }}} -repGuards :: [LGRHS Name (LHsExpr Name)] -> DsM (Core TH.BodyQ)+repGuards :: [LGRHS GhcRn (LHsExpr GhcRn)] -> DsM (Core TH.BodyQ) repGuards [L _ (GRHS [] e)] = do {a <- repLE e; repNormal a } repGuards other@@ -1316,7 +1292,8 @@ ; gd <- repGuarded (nonEmptyCoreList ys) ; wrapGenSyms (concat xs) gd } -repLGRHS :: LGRHS Name (LHsExpr Name) -> DsM ([GenSymBind], (Core (TH.Q (TH.Guard, TH.Exp))))+repLGRHS :: LGRHS GhcRn (LHsExpr GhcRn)+ -> DsM ([GenSymBind], (Core (TH.Q (TH.Guard, TH.Exp)))) repLGRHS (L _ (GRHS [L _ (BodyStmt e1 _ _ _)] e2)) = do { guarded <- repLNormalGE e1 e2 ; return ([], guarded) }@@ -1326,19 +1303,20 @@ ; guarded <- repPatGE (nonEmptyCoreList ss') rhs' ; return (gs, guarded) } -repFields :: HsRecordBinds Name -> DsM (Core [TH.Q TH.FieldExp])+repFields :: HsRecordBinds GhcRn -> DsM (Core [TH.Q TH.FieldExp]) repFields (HsRecFields { rec_flds = flds }) = repList fieldExpQTyConName rep_fld flds where- rep_fld :: LHsRecField Name (LHsExpr Name) -> DsM (Core (TH.Q TH.FieldExp))+ rep_fld :: LHsRecField GhcRn (LHsExpr GhcRn)+ -> DsM (Core (TH.Q TH.FieldExp)) rep_fld (L _ fld) = do { fn <- lookupLOcc (hsRecFieldSel fld) ; e <- repLE (hsRecFieldArg fld) ; repFieldExp fn e } -repUpdFields :: [LHsRecUpdField Name] -> DsM (Core [TH.Q TH.FieldExp])+repUpdFields :: [LHsRecUpdField GhcRn] -> DsM (Core [TH.Q TH.FieldExp]) repUpdFields = repList fieldExpQTyConName rep_fld where- rep_fld :: LHsRecUpdField Name -> DsM (Core (TH.Q TH.FieldExp))+ rep_fld :: LHsRecUpdField GhcRn -> DsM (Core (TH.Q TH.FieldExp)) rep_fld (L l fld) = case unLoc (hsRecFieldLbl fld) of Unambiguous _ sel_name -> do { fn <- lookupLOcc (L l sel_name) ; e <- repLE (hsRecFieldArg fld)@@ -1372,10 +1350,10 @@ -- The helper function repSts computes the translation of each sub expression -- and a bunch of prefix bindings denoting the dynamic renaming. -repLSts :: [LStmt Name (LHsExpr Name)] -> DsM ([GenSymBind], [Core TH.StmtQ])+repLSts :: [LStmt GhcRn (LHsExpr GhcRn)] -> DsM ([GenSymBind], [Core TH.StmtQ]) repLSts stmts = repSts (map unLoc stmts) -repSts :: [Stmt Name (LHsExpr Name)] -> DsM ([GenSymBind], [Core TH.StmtQ])+repSts :: [Stmt GhcRn (LHsExpr GhcRn)] -> DsM ([GenSymBind], [Core TH.StmtQ]) repSts (BindStmt p e _ _ _ : ss) = do { e2 <- repLE e ; ss1 <- mkGenSyms (collectPatBinders p)@@ -1402,7 +1380,8 @@ ; (ss2, zs) <- addBinds ss1 (repSts ss) ; return (ss1++ss2, z : zs) } where- rep_stmt_block :: ParStmtBlock Name Name -> DsM ([GenSymBind], Core [TH.StmtQ])+ rep_stmt_block :: ParStmtBlock GhcRn GhcRn+ -> DsM ([GenSymBind], Core [TH.StmtQ]) rep_stmt_block (ParStmtBlock stmts _ _) = do { (ss1, zs) <- repSts (map unLoc stmts) ; zs1 <- coreList stmtQTyConName zs@@ -1419,7 +1398,7 @@ -- Bindings ----------------------------------------------------------- -repBinds :: HsLocalBinds Name -> DsM ([GenSymBind], Core [TH.DecQ])+repBinds :: HsLocalBinds GhcRn -> DsM ([GenSymBind], Core [TH.DecQ]) repBinds EmptyLocalBinds = do { core_list <- coreList decQTyConName [] ; return ([], core_list) }@@ -1439,7 +1418,7 @@ (de_loc (sort_by_loc prs)) ; return (ss, core_list) } -rep_val_binds :: HsValBinds Name -> DsM [(SrcSpan, Core TH.DecQ)]+rep_val_binds :: HsValBinds GhcRn -> DsM [(SrcSpan, Core TH.DecQ)] -- Assumes: all the binders of the binding are already in the meta-env rep_val_binds (ValBindsOut binds sigs) = do { core1 <- rep_binds' (unionManyBags (map snd binds))@@ -1448,14 +1427,14 @@ rep_val_binds (ValBindsIn _ _) = panic "rep_val_binds: ValBindsIn" -rep_binds :: LHsBinds Name -> DsM [Core TH.DecQ]+rep_binds :: LHsBinds GhcRn -> DsM [Core TH.DecQ] rep_binds binds = do { binds_w_locs <- rep_binds' binds ; return (de_loc (sort_by_loc binds_w_locs)) } -rep_binds' :: LHsBinds Name -> DsM [(SrcSpan, Core TH.DecQ)]+rep_binds' :: LHsBinds GhcRn -> DsM [(SrcSpan, Core TH.DecQ)] rep_binds' = mapM rep_bind . bagToList -rep_bind :: LHsBind Name -> DsM (SrcSpan, Core TH.DecQ)+rep_bind :: LHsBind GhcRn -> DsM (SrcSpan, Core TH.DecQ) -- Assumes: all the binders of the binding are already in the meta-env -- Note GHC treats declarations of a variable (not a pattern)@@ -1464,8 +1443,8 @@ rep_bind (L loc (FunBind { fun_id = fn, fun_matches = MG { mg_alts- = L _ [L _ (Match _ [] _- (GRHSs guards (L _ wheres)))] } }))+ = L _ [L _ (Match { m_pats = []+ , m_grhss = GRHSs guards (L _ wheres) })] } })) = do { (ss,wherecore) <- repBinds wheres ; guardcore <- addBinds ss (repGuards guards) ; fn' <- lookupLBinder fn@@ -1500,7 +1479,6 @@ ; return (srcLocSpan (getSrcLoc v), ans) } rep_bind (L _ (AbsBinds {})) = panic "rep_bind: AbsBinds"-rep_bind (L _ (AbsBindsSig {})) = panic "rep_bind: AbsBindsSig" rep_bind (L loc (PatSynBind (PSB { psb_id = syn , psb_fvs = _fvs , psb_args = args@@ -1522,10 +1500,10 @@ -- API. Whereas inside GHC, record pattern synonym selectors and -- their pattern-only bound right hand sides have different names, -- we want to treat them the same in TH. This is the reason why we- -- need an adjusted mkGenArgSyms in the `RecordPatSyn` case below.- mkGenArgSyms (PrefixPatSyn args) = mkGenSyms (map unLoc args)- mkGenArgSyms (InfixPatSyn arg1 arg2) = mkGenSyms [unLoc arg1, unLoc arg2]- mkGenArgSyms (RecordPatSyn fields)+ -- need an adjusted mkGenArgSyms in the `RecCon` case below.+ mkGenArgSyms (PrefixCon args) = mkGenSyms (map unLoc args)+ mkGenArgSyms (InfixCon arg1 arg2) = mkGenSyms [unLoc arg1, unLoc arg2]+ mkGenArgSyms (RecCon fields) = do { let pats = map (unLoc . recordPatSynPatVar) fields sels = map (unLoc . recordPatSynSelectorId) fields ; ss <- mkGenSyms sels@@ -1537,8 +1515,8 @@ wrapGenArgSyms :: HsPatSynDetails (Located Name) -> [GenSymBind] -> Core TH.DecQ -> DsM (Core TH.DecQ)- wrapGenArgSyms (RecordPatSyn _) _ dec = return dec- wrapGenArgSyms _ ss dec = wrapGenSyms ss dec+ wrapGenArgSyms (RecCon _) _ dec = return dec+ wrapGenArgSyms _ ss dec = wrapGenSyms ss dec repPatSynD :: Core TH.Name -> Core TH.PatSynArgsQ@@ -1549,14 +1527,14 @@ = rep2 patSynDName [syn, args, dir, pat] repPatSynArgs :: HsPatSynDetails (Located Name) -> DsM (Core TH.PatSynArgsQ)-repPatSynArgs (PrefixPatSyn args)+repPatSynArgs (PrefixCon args) = do { args' <- repList nameTyConName lookupLOcc args ; repPrefixPatSynArgs args' }-repPatSynArgs (InfixPatSyn arg1 arg2)+repPatSynArgs (InfixCon arg1 arg2) = do { arg1' <- lookupLOcc arg1 ; arg2' <- lookupLOcc arg2 ; repInfixPatSynArgs arg1' arg2' }-repPatSynArgs (RecordPatSyn fields)+repPatSynArgs (RecCon fields) = do { sels' <- repList nameTyConName lookupLOcc sels ; repRecordPatSynArgs sels' } where sels = map recordPatSynSelectorId fields@@ -1571,7 +1549,7 @@ -> DsM (Core TH.PatSynArgsQ) repRecordPatSynArgs (MkC sels) = rep2 recordPatSynName [sels] -repPatSynDir :: HsPatSynDir Name -> DsM (Core TH.PatSynDirQ)+repPatSynDir :: HsPatSynDir GhcRn -> DsM (Core TH.PatSynDirQ) repPatSynDir Unidirectional = rep2 unidirPatSynName [] repPatSynDir ImplicitBidirectional = rep2 implBidirPatSynName [] repPatSynDir (ExplicitBidirectional (MG { mg_alts = L _ clauses }))@@ -1606,8 +1584,9 @@ -- Haskell Template's Meta.Exp type so we punt if it isn't a simple thing like -- (\ p1 .. pn -> exp) by causing an error. -repLambda :: LMatch Name (LHsExpr Name) -> DsM (Core TH.ExpQ)-repLambda (L _ (Match _ ps _ (GRHSs [L _ (GRHS [] e)] (L _ EmptyLocalBinds))))+repLambda :: LMatch GhcRn (LHsExpr GhcRn) -> DsM (Core TH.ExpQ)+repLambda (L _ (Match { m_pats = ps+ , m_grhss = GRHSs [L _ (GRHS [] e)] (L _ EmptyLocalBinds) } )) = do { let bndrs = collectPatsBinders ps ; ; ss <- mkGenSyms bndrs ; lam <- addBinds ss (@@ -1625,13 +1604,13 @@ -- variable should already appear in the environment. -- Process a list of patterns-repLPs :: [LPat Name] -> DsM (Core [TH.PatQ])+repLPs :: [LPat GhcRn] -> DsM (Core [TH.PatQ]) repLPs ps = repList patQTyConName repLP ps -repLP :: LPat Name -> DsM (Core TH.PatQ)+repLP :: LPat GhcRn -> DsM (Core TH.PatQ) repLP (L _ p) = repP p -repP :: Pat Name -> DsM (Core TH.PatQ)+repP :: Pat GhcRn -> DsM (Core TH.PatQ) repP (WildPat _) = repPwild repP (LitPat l) = do { l2 <- repLiteral l; repPlit l2 } repP (VarPat (L _ x)) = do { x' <- lookupBinder x; repPvar x' }@@ -1656,7 +1635,7 @@ repPinfix p1' con_str p2' } } where- rep_fld :: LHsRecField Name (LPat Name) -> DsM (Core (TH.Name,TH.PatQ))+ rep_fld :: LHsRecField GhcRn (LPat GhcRn) -> DsM (Core (TH.Name,TH.PatQ)) rep_fld (L _ fld) = do { MkC v <- lookupLOcc (hsRecFieldSel fld) ; MkC p <- repLP (hsRecFieldArg fld) ; rep2 fieldPatName [v,p] }@@ -1977,7 +1956,8 @@ repNormal (MkC e) = rep2 normalBName [e] ------------ Guards -----repLNormalGE :: LHsExpr Name -> LHsExpr Name -> DsM (Core (TH.Q (TH.Guard, TH.Exp)))+repLNormalGE :: LHsExpr GhcRn -> LHsExpr GhcRn+ -> DsM (Core (TH.Q (TH.Guard, TH.Exp))) repLNormalGE g e = do g' <- repLE g e' <- repLE e repNormalGE g' e'@@ -2028,8 +2008,8 @@ repFun :: Core TH.Name -> Core [TH.ClauseQ] -> DsM (Core TH.DecQ) repFun (MkC nm) (MkC b) = rep2 funDName [nm, b] -repData :: Core TH.CxtQ -> Core TH.Name -> Core [TH.TyVarBndr]- -> Maybe (Core [TH.TypeQ]) -> Core (Maybe TH.Kind)+repData :: Core TH.CxtQ -> Core TH.Name -> Core [TH.TyVarBndrQ]+ -> Maybe (Core [TH.TypeQ]) -> Core (Maybe TH.KindQ) -> Core [TH.ConQ] -> Core [TH.DerivClauseQ] -> DsM (Core TH.DecQ) repData (MkC cxt) (MkC nm) (MkC tvs) Nothing (MkC ksig) (MkC cons) (MkC derivs) = rep2 dataDName [cxt, nm, tvs, ksig, cons, derivs]@@ -2037,8 +2017,8 @@ (MkC derivs) = rep2 dataInstDName [cxt, nm, tys, ksig, cons, derivs] -repNewtype :: Core TH.CxtQ -> Core TH.Name -> Core [TH.TyVarBndr]- -> Maybe (Core [TH.TypeQ]) -> Core (Maybe TH.Kind)+repNewtype :: Core TH.CxtQ -> Core TH.Name -> Core [TH.TyVarBndrQ]+ -> Maybe (Core [TH.TypeQ]) -> Core (Maybe TH.KindQ) -> Core TH.ConQ -> Core [TH.DerivClauseQ] -> DsM (Core TH.DecQ) repNewtype (MkC cxt) (MkC nm) (MkC tvs) Nothing (MkC ksig) (MkC con) (MkC derivs)@@ -2047,7 +2027,7 @@ (MkC derivs) = rep2 newtypeInstDName [cxt, nm, tys, ksig, con, derivs] -repTySyn :: Core TH.Name -> Core [TH.TyVarBndr]+repTySyn :: Core TH.Name -> Core [TH.TyVarBndrQ] -> Core TH.TypeQ -> DsM (Core TH.DecQ) repTySyn (MkC nm) (MkC tvs) (MkC rhs) = rep2 tySynDName [nm, tvs, rhs]@@ -2087,7 +2067,7 @@ just = coreJust overlapTyConName -repClass :: Core TH.CxtQ -> Core TH.Name -> Core [TH.TyVarBndr]+repClass :: Core TH.CxtQ -> Core TH.Name -> Core [TH.TyVarBndrQ] -> Core [TH.FunDep] -> Core [TH.DecQ] -> DsM (Core TH.DecQ) repClass (MkC cxt) (MkC cls) (MkC tvs) (MkC fds) (MkC ds)@@ -2132,22 +2112,22 @@ repTySynInst (MkC nm) (MkC eqn) = rep2 tySynInstDName [nm, eqn] -repDataFamilyD :: Core TH.Name -> Core [TH.TyVarBndr]- -> Core (Maybe TH.Kind) -> DsM (Core TH.DecQ)+repDataFamilyD :: Core TH.Name -> Core [TH.TyVarBndrQ]+ -> Core (Maybe TH.KindQ) -> DsM (Core TH.DecQ) repDataFamilyD (MkC nm) (MkC tvs) (MkC kind) = rep2 dataFamilyDName [nm, tvs, kind] repOpenFamilyD :: Core TH.Name- -> Core [TH.TyVarBndr]- -> Core TH.FamilyResultSig+ -> Core [TH.TyVarBndrQ]+ -> Core TH.FamilyResultSigQ -> Core (Maybe TH.InjectivityAnn) -> DsM (Core TH.DecQ) repOpenFamilyD (MkC nm) (MkC tvs) (MkC result) (MkC inj) = rep2 openTypeFamilyDName [nm, tvs, result, inj] repClosedFamilyD :: Core TH.Name- -> Core [TH.TyVarBndr]- -> Core TH.FamilyResultSig+ -> Core [TH.TyVarBndrQ]+ -> Core TH.FamilyResultSigQ -> Core (Maybe TH.InjectivityAnn) -> Core [TH.TySynEqnQ] -> DsM (Core TH.DecQ)@@ -2171,15 +2151,15 @@ repCtxt (MkC tys) = rep2 cxtName [tys] repDataCon :: Located Name- -> HsConDeclDetails Name+ -> HsConDeclDetails GhcRn -> DsM (Core TH.ConQ) repDataCon con details = do con' <- lookupLOcc con -- See Note [Binders and occurrences] repConstr details Nothing [con'] repGadtDataCons :: [Located Name]- -> HsConDeclDetails Name- -> LHsType Name+ -> HsConDeclDetails GhcRn+ -> LHsType GhcRn -> DsM (Core TH.ConQ) repGadtDataCons cons details res_ty = do cons' <- mapM lookupLOcc cons -- See Note [Binders and occurrences]@@ -2190,8 +2170,8 @@ -- argument is a singleton list -- * for GADTs data constructors second argument is (Just return_type) and -- third argument is a non-empty list-repConstr :: HsConDeclDetails Name- -> Maybe (LHsType Name)+repConstr :: HsConDeclDetails GhcRn+ -> Maybe (LHsType GhcRn) -> [Core TH.Name] -> DsM (Core TH.ConQ) repConstr (PrefixCon ps) Nothing [con]@@ -2216,7 +2196,7 @@ where rep_ip (L _ ip) = mapM (rep_one_ip (cd_fld_type ip)) (cd_fld_names ip) - rep_one_ip :: LBangType Name -> LFieldOcc Name -> DsM (Core a)+ rep_one_ip :: LBangType GhcRn -> LFieldOcc GhcRn -> DsM (Core a) rep_one_ip t n = do { MkC v <- lookupOcc (selectorFieldOcc $ unLoc n) ; MkC ty <- repBangTy t ; rep2 varBangTypeName [v,ty] }@@ -2233,7 +2213,7 @@ ------------ Types ------------------- -repTForall :: Core [TH.TyVarBndr] -> Core TH.CxtQ -> Core TH.TypeQ+repTForall :: Core [TH.TyVarBndrQ] -> Core TH.CxtQ -> Core TH.TypeQ -> DsM (Core TH.TypeQ) repTForall (MkC tvars) (MkC ctxt) (MkC ty) = rep2 forallTName [tvars, ctxt, ty]@@ -2248,7 +2228,7 @@ repTapps f [] = return f repTapps f (t:ts) = do { f1 <- repTapp f t; repTapps f1 ts } -repTSig :: Core TH.TypeQ -> Core TH.Kind -> DsM (Core TH.TypeQ)+repTSig :: Core TH.TypeQ -> Core TH.KindQ -> DsM (Core TH.TypeQ) repTSig (MkC ty) (MkC ki) = rep2 sigTName [ty, ki] repTequality :: DsM (Core TH.TypeQ)@@ -2268,6 +2248,12 @@ repTWildCard :: DsM (Core TH.TypeQ) repTWildCard = rep2 wildCardTName [] +repTStar :: DsM (Core TH.TypeQ)+repTStar = rep2 starKName []++repTConstraint :: DsM (Core TH.TypeQ)+repTConstraint = rep2 constraintKName []+ --------- Type constructors -------------- repNamedTyCon :: Core TH.Name -> DsM (Core TH.TypeQ)@@ -2307,59 +2293,30 @@ repPromotedConsTyCon :: DsM (Core TH.TypeQ) repPromotedConsTyCon = rep2 promotedConsTName [] ------------- Kinds -------------------+------------ TyVarBndrs ------------------- -repPlainTV :: Core TH.Name -> DsM (Core TH.TyVarBndr)+repPlainTV :: Core TH.Name -> DsM (Core TH.TyVarBndrQ) repPlainTV (MkC nm) = rep2 plainTVName [nm] -repKindedTV :: Core TH.Name -> Core TH.Kind -> DsM (Core TH.TyVarBndr)+repKindedTV :: Core TH.Name -> Core TH.KindQ -> DsM (Core TH.TyVarBndrQ) repKindedTV (MkC nm) (MkC ki) = rep2 kindedTVName [nm, ki] -repKVar :: Core TH.Name -> DsM (Core TH.Kind)-repKVar (MkC s) = rep2 varKName [s]--repKCon :: Core TH.Name -> DsM (Core TH.Kind)-repKCon (MkC s) = rep2 conKName [s]--repKTuple :: Int -> DsM (Core TH.Kind)-repKTuple i = do dflags <- getDynFlags- rep2 tupleKName [mkIntExprInt dflags i]--repKArrow :: DsM (Core TH.Kind)-repKArrow = rep2 arrowKName []--repKList :: DsM (Core TH.Kind)-repKList = rep2 listKName []--repKApp :: Core TH.Kind -> Core TH.Kind -> DsM (Core TH.Kind)-repKApp (MkC k1) (MkC k2) = rep2 appKName [k1, k2]--repKApps :: Core TH.Kind -> [Core TH.Kind] -> DsM (Core TH.Kind)-repKApps f [] = return f-repKApps f (k:ks) = do { f' <- repKApp f k; repKApps f' ks }--repKStar :: DsM (Core TH.Kind)-repKStar = rep2 starKName []--repKConstraint :: DsM (Core TH.Kind)-repKConstraint = rep2 constraintKName []- ---------------------------------------------------------- -- Type family result signature -repNoSig :: DsM (Core TH.FamilyResultSig)+repNoSig :: DsM (Core TH.FamilyResultSigQ) repNoSig = rep2 noSigName [] -repKindSig :: Core TH.Kind -> DsM (Core TH.FamilyResultSig)+repKindSig :: Core TH.KindQ -> DsM (Core TH.FamilyResultSigQ) repKindSig (MkC ki) = rep2 kindSigName [ki] -repTyVarSig :: Core TH.TyVarBndr -> DsM (Core TH.FamilyResultSig)+repTyVarSig :: Core TH.TyVarBndrQ -> DsM (Core TH.FamilyResultSigQ) repTyVarSig (MkC bndr) = rep2 tyVarSigName [bndr] ---------------------------------------------------------- -- Literals -repLiteral :: HsLit -> DsM (Core TH.Lit)+repLiteral :: HsLit GhcRn -> DsM (Core TH.Lit) repLiteral (HsStringPrim _ bs) = do dflags <- getDynFlags word8_ty <- lookupType word8TyConName@@ -2371,9 +2328,9 @@ = do lit' <- case lit of HsIntPrim _ i -> mk_integer i HsWordPrim _ w -> mk_integer w- HsInt _ i -> mk_integer i- HsFloatPrim r -> mk_rational r- HsDoublePrim r -> mk_rational r+ HsInt _ i -> mk_integer (il_value i)+ HsFloatPrim _ r -> mk_rational r+ HsDoublePrim _ r -> mk_rational r HsCharPrim _ c -> mk_char c _ -> return lit lit_expr <- dsLit lit'@@ -2383,38 +2340,39 @@ where mb_lit_name = case lit of HsInteger _ _ _ -> Just integerLName- HsInt _ _ -> Just integerLName+ HsInt _ _ -> Just integerLName HsIntPrim _ _ -> Just intPrimLName HsWordPrim _ _ -> Just wordPrimLName- HsFloatPrim _ -> Just floatPrimLName- HsDoublePrim _ -> Just doublePrimLName+ HsFloatPrim _ _ -> Just floatPrimLName+ HsDoublePrim _ _ -> Just doublePrimLName HsChar _ _ -> Just charLName HsCharPrim _ _ -> Just charPrimLName HsString _ _ -> Just stringLName- HsRat _ _ -> Just rationalLName+ HsRat _ _ _ -> Just rationalLName _ -> Nothing -mk_integer :: Integer -> DsM HsLit+mk_integer :: Integer -> DsM (HsLit GhcRn) mk_integer i = do integer_ty <- lookupType integerTyConName- return $ HsInteger NoSourceText i integer_ty-mk_rational :: FractionalLit -> DsM HsLit+ return $ HsInteger noSourceText i integer_ty++mk_rational :: FractionalLit -> DsM (HsLit GhcRn) mk_rational r = do rat_ty <- lookupType rationalTyConName- return $ HsRat r rat_ty-mk_string :: FastString -> DsM HsLit-mk_string s = return $ HsString NoSourceText s+ return $ HsRat def r rat_ty+mk_string :: FastString -> DsM (HsLit GhcRn)+mk_string s = return $ HsString noSourceText s -mk_char :: Char -> DsM HsLit-mk_char c = return $ HsChar NoSourceText c+mk_char :: Char -> DsM (HsLit GhcRn)+mk_char c = return $ HsChar noSourceText c -repOverloadedLiteral :: HsOverLit Name -> DsM (Core TH.Lit)+repOverloadedLiteral :: HsOverLit GhcRn -> DsM (Core TH.Lit) repOverloadedLiteral (OverLit { ol_val = val}) = do { lit <- mk_lit val; repLiteral lit } -- The type Rational will be in the environment, because -- the smart constructor 'TH.Syntax.rationalL' uses it in its type, -- and rationalL is sucked in when any TH stuff is used -mk_lit :: OverLitVal -> DsM HsLit-mk_lit (HsIntegral _ i) = mk_integer i+mk_lit :: OverLitVal -> DsM (HsLit GhcRn)+mk_lit (HsIntegral i) = mk_integer (il_value i) mk_lit (HsFractional f) = mk_rational f mk_lit (HsIsString _ s) = mk_string s @@ -2438,16 +2396,22 @@ repUnboundVar :: Core TH.Name -> DsM (Core TH.ExpQ) repUnboundVar (MkC name) = rep2 unboundVarEName [name] +repOverLabel :: FastString -> DsM (Core TH.ExpQ)+repOverLabel fs = do+ (MkC s) <- coreStringLit $ unpackFS fs+ rep2 labelEName [s]++ ------------ Lists ------------------- -- turn a list of patterns into a single pattern matching a list repList :: Name -> (a -> DsM (Core b))- -> [a] -> DsM (Core [b])+ -> [a] -> DsM (Core [b]) repList tc_name f args = do { args1 <- mapM f args ; coreList tc_name args1 } -coreList :: Name -- Of the TyCon of the element type+coreList :: Name -- Of the TyCon of the element type -> [Core a] -> DsM (Core [a]) coreList tc_name es = do { elt_ty <- lookupType tc_name; return (coreList' elt_ty es) }
deSugar/DsMonad.hs view
@@ -49,9 +49,14 @@ CanItFail(..), orFail, -- Levity polymorphism- dsNoLevPoly, dsNoLevPolyExpr, dsWhenNoErrs+ dsNoLevPoly, dsNoLevPolyExpr, dsWhenNoErrs,++ -- Trace injection+ pprRuntimeTrace ) where +import GhcPrelude+ import TcRnMonad import FamInstEnv import CoreSyn@@ -85,6 +90,7 @@ import Var (EvVar) import qualified GHC.LanguageExtensions as LangExt import UniqFM ( lookupWithDefaultUFM )+import Literal ( mkMachString ) import Data.IORef import Control.Monad@@ -105,7 +111,7 @@ ppr (DsMatchContext hs_match ss) = ppr ss <+> pprMatchContext hs_match data EquationInfo- = EqnInfo { eqn_pats :: [Pat Id], -- The patterns for an eqn+ = EqnInfo { eqn_pats :: [Pat GhcTc], -- The patterns for an eqn eqn_rhs :: MatchResult } -- What to do after match instance Outputable EquationInfo where@@ -289,8 +295,7 @@ Note [Levity polymorphism checking] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-According to the Levity Polymorphism paper-<http://cs.brynmawr.edu/~rae/papers/2017/levity/levity.pdf>, levity+According to the "Levity Polymorphism" paper (PLDI '17), levity polymorphism is forbidden in precisely two places: in the type of a bound term-level argument and in the type of an argument to a function. The paper explains it more fully, but briefly: expressions in these contexts need to be@@ -731,3 +736,31 @@ _ -> pprPanic multipleNames (ppr occ) } where multipleNames = "Multiple definitions in 'Data.Array.Parallel' and 'Data.Array.Parallel.Prim':"++-- | Inject a trace message into the compiled program. Whereas+-- pprTrace prints out information *while compiling*, pprRuntimeTrace+-- captures that information and causes it to be printed *at runtime*+-- using Debug.Trace.trace.+--+-- pprRuntimeTrace hdr doc expr+--+-- will produce an expression that looks like+--+-- trace (hdr + doc) expr+--+-- When using this to debug a module that Debug.Trace depends on,+-- it is necessary to import {-# SOURCE #-} Debug.Trace () in that+-- module. We could avoid this inconvenience by wiring in Debug.Trace.trace,+-- but that doesn't seem worth the effort and maintenance cost.+pprRuntimeTrace :: String -- ^ header+ -> SDoc -- ^ information to output+ -> CoreExpr -- ^ expression+ -> DsM CoreExpr+pprRuntimeTrace str doc expr = do+ traceId <- dsLookupGlobalId traceName+ unpackCStringId <- dsLookupGlobalId unpackCStringName+ dflags <- getDynFlags+ let message :: CoreExpr+ message = App (Var unpackCStringId) $+ Lit $ mkMachString $ showSDoc dflags (hang (text str) 4 doc)+ return $ mkApps (Var traceId) [Type (exprType expr), message, expr]
deSugar/DsUsage.hs view
@@ -7,6 +7,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags import HscTypes import TcRnTypes
deSugar/DsUtils.hs view
@@ -40,6 +40,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} Match ( matchSimply ) import {-# SOURCE #-} DsExpr ( dsLExpr ) @@ -92,7 +94,7 @@ otherwise, make one up. -} -selectSimpleMatchVarL :: LPat Id -> DsM Id+selectSimpleMatchVarL :: LPat GhcTc -> DsM Id selectSimpleMatchVarL pat = selectMatchVar (unLoc pat) -- (selectMatchVars ps tys) chooses variables of type tys@@ -111,10 +113,10 @@ -- Then we must not choose (x::Int) as the matching variable! -- And nowadays we won't, because the (x::Int) will be wrapped in a CoPat -selectMatchVars :: [Pat Id] -> DsM [Id]+selectMatchVars :: [Pat GhcTc] -> DsM [Id] selectMatchVars ps = mapM selectMatchVar ps -selectMatchVar :: Pat Id -> DsM Id+selectMatchVar :: Pat GhcTc -> DsM Id selectMatchVar (BangPat pat) = selectMatchVar (unLoc pat) selectMatchVar (LazyPat pat) = selectMatchVar (unLoc pat) selectMatchVar (ParPat pat) = selectMatchVar (unLoc pat)@@ -174,7 +176,7 @@ worthy of a type synonym and a few handy functions. -} -firstPat :: EquationInfo -> Pat Id+firstPat :: EquationInfo -> Pat GhcTc firstPat eqn = ASSERT( notNull (eqn_pats eqn) ) head (eqn_pats eqn) shiftEqns :: [EquationInfo] -> [EquationInfo]@@ -255,7 +257,7 @@ = MatchResult CanFail (\fail -> do body <- body_fn fail return (mkIfThenElse pred_expr body fail)) -mkCoPrimCaseMatchResult :: Id -- Scrutinee+mkCoPrimCaseMatchResult :: Id -- Scrutinee -> Type -- Type of the case -> [(Literal, MatchResult)] -- Alternatives -> MatchResult -- Literals are all unlifted@@ -414,7 +416,8 @@ -- parallel arrays, which are introduced by `tidy1' in the `PArrPat' -- case ---mkPArrCase :: DynFlags -> Id -> Type -> [CaseAlt DataCon] -> CoreExpr -> DsM CoreExpr+mkPArrCase :: DynFlags -> Id -> Type -> [CaseAlt DataCon] -> CoreExpr+ -> DsM CoreExpr mkPArrCase dflags var ty sorted_alts fail = do lengthP <- dsDPHBuiltin lengthPVar alt <- unboxAlt@@ -725,7 +728,7 @@ -} mkSelectorBinds :: [[Tickish Id]] -- ^ ticks to add, possibly- -> LPat Id -- ^ The pattern+ -> LPat GhcTc -- ^ The pattern -> CoreExpr -- ^ Expression to which the pattern is bound -> DsM (Id,[(Id,CoreExpr)]) -- ^ Id the rhs is bound to, for desugaring strict@@ -814,31 +817,31 @@ * * ********************************************************************* -} -mkLHsPatTup :: [LPat Id] -> LPat Id+mkLHsPatTup :: [LPat GhcTc] -> LPat GhcTc mkLHsPatTup [] = noLoc $ mkVanillaTuplePat [] Boxed mkLHsPatTup [lpat] = lpat mkLHsPatTup lpats = L (getLoc (head lpats)) $ mkVanillaTuplePat lpats Boxed -mkLHsVarPatTup :: [Id] -> LPat Id+mkLHsVarPatTup :: [Id] -> LPat GhcTc mkLHsVarPatTup bs = mkLHsPatTup (map nlVarPat bs) -mkVanillaTuplePat :: [OutPat Id] -> Boxity -> Pat Id+mkVanillaTuplePat :: [OutPat GhcTc] -> Boxity -> Pat GhcTc -- A vanilla tuple pattern simply gets its type from its sub-patterns mkVanillaTuplePat pats box = TuplePat pats box (map hsLPatType pats) -- The Big equivalents for the source tuple expressions-mkBigLHsVarTupId :: [Id] -> LHsExpr Id+mkBigLHsVarTupId :: [Id] -> LHsExpr GhcTc mkBigLHsVarTupId ids = mkBigLHsTupId (map nlHsVar ids) -mkBigLHsTupId :: [LHsExpr Id] -> LHsExpr Id+mkBigLHsTupId :: [LHsExpr GhcTc] -> LHsExpr GhcTc mkBigLHsTupId = mkChunkified mkLHsTupleExpr -- The Big equivalents for the source tuple patterns-mkBigLHsVarPatTupId :: [Id] -> LPat Id+mkBigLHsVarPatTupId :: [Id] -> LPat GhcTc mkBigLHsVarPatTupId bs = mkBigLHsPatTupId (map nlVarPat bs) -mkBigLHsPatTupId :: [LPat Id] -> LPat Id+mkBigLHsPatTupId :: [LPat GhcTc] -> LPat GhcTc mkBigLHsPatTupId = mkChunkified mkLHsPatTup {-
deSugar/Match.hs view
@@ -7,11 +7,14 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module Match ( match, matchEquations, matchWrapper, matchSimply, matchSinglePat ) where #include "HsVersions.h" +import GhcPrelude+ import {-#SOURCE#-} DsExpr (dsLExpr, dsSyntaxExpr) import DynFlags@@ -39,19 +42,19 @@ import TcType ( toTcTypeBag ) import TyCon( isNewTyCon ) import TysWiredIn-import ListSetOps import SrcLoc import Maybes import Util import Name import Outputable-import BasicTypes ( isGenerated, fl_value )+import BasicTypes ( isGenerated, il_value, fl_value ) import FastString import Unique import UniqDFM import Control.Monad( when, unless ) import qualified Data.Map as Map+import Data.List (groupBy) {- ************************************************************************@@ -60,7 +63,8 @@ * * ************************************************************************ -The function @match@ is basically the same as in the Wadler chapter,+The function @match@ is basically the same as in the Wadler chapter+from "The Implementation of Functional Programming Languages", except it is monadised, to carry around the name supply, info about annotations, etc. @@ -122,44 +126,29 @@ \item Tidy the patterns in column~1 with @tidyEqnInfo@ (this may add bindings to the second component of the equation-info):-\begin{itemize} \item-Remove the `as' patterns from column~1.-\item-Make all constructor patterns in column~1 into @ConPats@, notably-@ListPats@ and @TuplePats@.-\item-Handle any irrefutable (or ``twiddle'') @LazyPats@.-\end{itemize}-\item Now {\em unmix} the equations into {\em blocks} [w\/ local function-@unmix_eqns@], in which the equations in a block all have variable-patterns in column~1, or they all have constructor patterns in ...+@match_groups@], in which the equations in a block all have the same+ match group. (see ``the mixture rule'' in SLPJ). \item-Call @matchEqnBlock@ on each block of equations; it will do the-appropriate thing for each kind of column-1 pattern, usually ending up-in a recursive call to @match@.+Call the right match variant on each block of equations; it will do the+appropriate thing for each kind of column-1 pattern. \end{enumerate} We are a little more paranoid about the ``empty rule'' (SLPJ, p.~87) than the Wadler-chapter code for @match@ (p.~93, first @match@ clause). And gluing the ``success expressions'' together isn't quite so pretty. -This (more interesting) clause of @match@ uses @tidy_and_unmix_eqns@-(a)~to get `as'- and `twiddle'-patterns out of the way (tidying), and-(b)~to do ``the mixture rule'' (SLPJ, p.~88) [which really {\em+This @match@ uses @tidyEqnInfo@+to get `as'- and `twiddle'-patterns out of the way (tidying), before+applying ``the mixture rule'' (SLPJ, p.~88) [which really {\em un}mixes the equations], producing a list of equation-info-blocks, each block having as its first column of patterns either all-constructors, or all variables (or similar beasts), etc.--@match_unmixed_eqn_blks@ simply takes the place of the @foldr@ in the-Wadler-chapter @match@ (p.~93, last clause), and @match_unmixed_blk@-corresponds roughly to @matchVarCon@.+blocks, each block having as its first column patterns compatible with each other. Note [Match Ids] ~~~~~~~~~~~~~~~~-Most of the matching fuctions take an Id or [Id] as argument. This Id+Most of the matching functions take an Id or [Id] as argument. This Id is the scrutinee(s) of the match. The desugared expression may sometimes use that Id in a local binding or as a case binder. So it should not have an External name; Lint rejects non-top-level binders@@ -304,12 +293,12 @@ matchOverloadedList _ _ _ = panic "matchOverloadedList" -- decompose the first pattern and leave the rest alone-decomposeFirstPat :: (Pat Id -> Pat Id) -> EquationInfo -> EquationInfo+decomposeFirstPat :: (Pat GhcTc -> Pat GhcTc) -> EquationInfo -> EquationInfo decomposeFirstPat extractpat (eqn@(EqnInfo { eqn_pats = pat : pats })) = eqn { eqn_pats = extractpat pat : pats} decomposeFirstPat _ _ = panic "decomposeFirstPat" -getCoPat, getBangPat, getViewPat, getOLPat :: Pat Id -> Pat Id+getCoPat, getBangPat, getViewPat, getOLPat :: Pat GhcTc -> Pat GhcTc getCoPat (CoPat _ pat _) = pat getCoPat _ = panic "getCoPat" getBangPat (BangPat pat ) = unLoc pat@@ -345,39 +334,40 @@ ************************************************************************ Tidy up the leftmost pattern in an @EquationInfo@, given the variable @v@-which will be scrutinised. This means:-\begin{itemize}-\item-Replace variable patterns @x@ (@x /= v@) with the pattern @_@,-together with the binding @x = v@.-\item-Replace the `as' pattern @x@@p@ with the pattern p and a binding @x = v@.-\item-Removing lazy (irrefutable) patterns (you don't want to know...).-\item-Converting explicit tuple-, list-, and parallel-array-pats into ordinary-@ConPats@.-\item-Convert the literal pat "" to [].-\end{itemize}+which will be scrutinised. -The result of this tidying is that the column of patterns will include-{\em only}:-\begin{description}-\item[@WildPats@:]-The @VarPat@ information isn't needed any more after this.+This makes desugaring the pattern match simpler by transforming some of+the patterns to simpler forms. (Tuples to Constructor Patterns) -\item[@ConPats@:]-@ListPats@, @TuplePats@, etc., are all converted into @ConPats@.+Among other things in the resulting Pattern:+* Variables and irrefutable(lazy) patterns are replaced by Wildcards+* As patterns are replaced by the patterns they wrap. -\item[@LitPats@ and @NPats@:]-@LitPats@/@NPats@ of ``known friendly types'' (Int, Char,-Float, Double, at least) are converted to unboxed form; e.g.,-\tr{(NPat (HsInt i) _ _)} is converted to:-\begin{verbatim}-(ConPat I# _ _ [LitPat (HsIntPrim i)])-\end{verbatim}-\end{description}+The bindings created by the above patterns are put into the returned wrapper+instead.++This means a definition of the form:+ f x = rhs+when called with v get's desugared to the equivalent of:+ let x = v+ in+ f _ = rhs++The same principle holds for as patterns (@) and+irrefutable/lazy patterns (~).+In the case of irrefutable patterns the irrefutable pattern is pushed into+the binding.++Pattern Constructors which only represent syntactic sugar are converted into+their desugared representation.+This usually means converting them to Constructor patterns but for some+depends on enabled extensions. (Eg OverloadedLists)++GHC also tries to convert overloaded Literals into regular ones.++The result of this tidying is that the column of patterns will include+only these which can be assigned a PatternGroup (see patGroup).+ -} tidyEqnInfo :: Id -> EquationInfo@@ -388,12 +378,7 @@ -- one pattern and fiddling the list of bindings. -- -- POST CONDITION: head pattern in the EqnInfo is- -- WildPat- -- ConPat- -- NPat- -- LitPat- -- NPlusKPat- -- but no other+ -- one of these for which patGroup is defined. tidyEqnInfo _ (EqnInfo { eqn_pats = [] }) = panic "tidyEqnInfo"@@ -402,21 +387,16 @@ = do { (wrap, pat') <- tidy1 v pat ; return (wrap, eqn { eqn_pats = do pat' : pats }) } -tidy1 :: Id -- The Id being scrutinised- -> Pat Id -- The pattern against which it is to be matched- -> DsM (DsWrapper, -- Extra bindings to do before the match- Pat Id) -- Equivalent pattern+tidy1 :: Id -- The Id being scrutinised+ -> Pat GhcTc -- The pattern against which it is to be matched+ -> DsM (DsWrapper, -- Extra bindings to do before the match+ Pat GhcTc) -- Equivalent pattern ------------------------------------------------------- -- (pat', mr') = tidy1 v pat mr -- tidies the *outer level only* of pat, giving pat' -- It eliminates many pattern forms (as-patterns, variable patterns,--- list patterns, etc) yielding one of:--- WildPat--- ConPatOut--- LitPat--- NPat--- NPlusKPat+-- list patterns, etc) and returns any created bindings in the wrapper. tidy1 v (ParPat pat) = tidy1 v (unLoc pat) tidy1 v (SigPatOut pat _) = tidy1 v (unLoc pat)@@ -501,7 +481,7 @@ = return (idDsWrapper, non_interesting_pat) ---------------------tidy_bang_pat :: Id -> SrcSpan -> Pat Id -> DsM (DsWrapper, Pat Id)+tidy_bang_pat :: Id -> SrcSpan -> Pat GhcTc -> DsM (DsWrapper, Pat GhcTc) -- Discard par/sig under a bang tidy_bang_pat v _ (ParPat (L l p)) = tidy_bang_pat v l p@@ -552,7 +532,7 @@ push_bang_into_newtype_arg :: SrcSpan -> Type -- The type of the argument we are pushing -- onto- -> HsConPatDetails Id -> HsConPatDetails Id+ -> HsConPatDetails GhcTc -> HsConPatDetails GhcTc -- See Note [Bang patterns and newtypes] -- We are transforming !(N p) into (N !p) push_bang_into_newtype_arg l _ty (PrefixCon (arg:args))@@ -662,7 +642,7 @@ arguments: \begin{itemize} \item-Typchecked @Matches@ (of a function definition, or a case or lambda+Typechecked @Matches@ (of a function definition, or a case or lambda expression)---the main input; \item An error message to be inserted into any (runtime) pattern-matching@@ -695,10 +675,10 @@ \end{enumerate} -} -matchWrapper :: HsMatchContext Name -- For shadowing warning messages- -> Maybe (LHsExpr Id) -- The scrutinee, if we check a case expr- -> MatchGroup Id (LHsExpr Id) -- Matches being desugared- -> DsM ([Id], CoreExpr) -- Results+matchWrapper :: HsMatchContext Name -- For shadowing warning messages+ -> Maybe (LHsExpr GhcTc) -- The scrutinee, if we check a case expr+ -> MatchGroup GhcTc (LHsExpr GhcTc) -- Matches being desugared+ -> DsM ([Id], CoreExpr) -- Results {- There is one small problem with the Lambda Patterns, when somebody@@ -748,19 +728,14 @@ matchEquations ctxt new_vars eqns_info rhs_ty ; return (new_vars, result_expr) } where- mk_eqn_info vars (L _ (Match ctx pats _ grhss))+ mk_eqn_info vars (L _ (Match { m_pats = pats, m_grhss = grhss })) = do { dflags <- getDynFlags- ; let add_bang- | FunRhs {mc_strictness=SrcStrict} <- ctx- = pprTrace "addBang" empty addBang- | otherwise- = decideBangHood dflags- upats = map (unLoc . add_bang) pats+ ; let upats = map (unLoc . decideBangHood dflags) pats dicts = toTcTypeBag (collectEvVarsPats upats) -- Only TcTyVars ; tm_cs <- genCaseTmCs2 mb_scr upats vars ; match_result <- addDictsDs dicts $ -- See Note [Type and Term Equality Propagation] addTmCsDs tm_cs $ -- See Note [Type and Term Equality Propagation]- dsGRHSs ctxt upats grhss rhs_ty+ dsGRHSs ctxt grhss rhs_ty ; return (EqnInfo { eqn_pats = upats, eqn_rhs = match_result}) } handleWarnings = if isGenerated origin@@ -793,7 +768,7 @@ matchSimply :: CoreExpr -- Scrutinee -> HsMatchContext Name -- Match kind- -> LPat Id -- Pattern it should match+ -> LPat GhcTc -- Pattern it should match -> CoreExpr -- Return this if it matches -> CoreExpr -- Return this if it doesn't -> DsM CoreExpr@@ -806,7 +781,7 @@ match_result' <- matchSinglePat scrut hs_ctx pat rhs_ty match_result extractMatchResult match_result' fail_expr -matchSinglePat :: CoreExpr -> HsMatchContext Name -> LPat Id+matchSinglePat :: CoreExpr -> HsMatchContext Name -> LPat GhcTc -> Type -> MatchResult -> DsM MatchResult -- matchSinglePat ensures that the scrutinee is a variable -- and then calls match_single_pat_var@@ -825,7 +800,7 @@ ; return (adjustMatchResult (bindNonRec var scrut) match_result') } match_single_pat_var :: Id -- See Note [Match Ids]- -> HsMatchContext Name -> LPat Id+ -> HsMatchContext Name -> LPat GhcTc -> Type -> MatchResult -> DsM MatchResult match_single_pat_var var ctx pat ty match_result = ASSERT2( isInternalName (idName var), ppr var )@@ -861,7 +836,7 @@ | PgBang -- Bang patterns | PgCo Type -- Coercion patterns; the type is the type -- of the pattern *inside*- | PgView (LHsExpr Id) -- view pattern (e -> p):+ | PgView (LHsExpr GhcTc) -- view pattern (e -> p): -- the LHsExpr is the expression e Type -- the Type is the type of p (equivalently, the result type of e) | PgOverloadedList@@ -892,7 +867,7 @@ -- (b) none of the gi are empty -- The ordering of equations is unchanged groupEquations dflags eqns- = runs same_gp [(patGroup dflags (firstPat eqn), eqn) | eqn <- eqns]+ = groupBy same_gp [(patGroup dflags (firstPat eqn), eqn) | eqn <- eqns] where same_gp :: (PatGroup,EquationInfo) -> (PatGroup,EquationInfo) -> Bool (pg1,_) `same_gp` (pg2,_) = pg1 `sameGroup` pg2@@ -990,14 +965,14 @@ -- NB we can't assume that the two view expressions have the same type. Consider -- f (e1 -> True) = ... -- f (e2 -> "hi") = ...-viewLExprEq :: (LHsExpr Id,Type) -> (LHsExpr Id,Type) -> Bool+viewLExprEq :: (LHsExpr GhcTc,Type) -> (LHsExpr GhcTc,Type) -> Bool viewLExprEq (e1,_) (e2,_) = lexp e1 e2 where- lexp :: LHsExpr Id -> LHsExpr Id -> Bool+ lexp :: LHsExpr GhcTc -> LHsExpr GhcTc -> Bool lexp e e' = exp (unLoc e) (unLoc e') ---------- exp :: HsExpr Id -> HsExpr Id -> Bool+ exp :: HsExpr GhcTc -> HsExpr GhcTc -> Bool -- real comparison is on HsExpr's -- strip parens exp (HsPar (L _ e)) e' = exp e e'@@ -1042,7 +1017,7 @@ exp _ _ = False ---------- syn_exp :: SyntaxExpr Id -> SyntaxExpr Id -> Bool+ syn_exp :: SyntaxExpr GhcTc -> SyntaxExpr GhcTc -> Bool syn_exp (SyntaxExpr { syn_expr = expr1 , syn_arg_wraps = arg_wraps1 , syn_res_wrap = res_wrap1 })@@ -1089,7 +1064,7 @@ eq_list _ (_:_) [] = False eq_list eq (x:xs) (y:ys) = eq x y && eq_list eq xs ys -patGroup :: DynFlags -> Pat Id -> PatGroup+patGroup :: DynFlags -> Pat GhcTc -> PatGroup patGroup _ (ConPatOut { pat_con = L _ con , pat_arg_tys = tys }) | RealDataCon dcon <- con = PgCon dcon@@ -1098,15 +1073,15 @@ patGroup _ (BangPat {}) = PgBang patGroup _ (NPat (L _ OverLit {ol_val=oval}) mb_neg _ _) = case (oval, isJust mb_neg) of- (HsIntegral _ i, False) -> PgN (fromInteger i)- (HsIntegral _ i, True ) -> PgN (-fromInteger i)+ (HsIntegral i, False) -> PgN (fromInteger (il_value i))+ (HsIntegral i, True ) -> PgN (-fromInteger (il_value i)) (HsFractional r, False) -> PgN (fl_value r) (HsFractional r, True ) -> PgN (-fl_value r) (HsIsString _ s, _) -> ASSERT(isNothing mb_neg) PgOverS s patGroup _ (NPlusKPat _ (L _ OverLit {ol_val=oval}) _ _ _ _) = case oval of- HsIntegral _ i -> PgNpK i+ HsIntegral i -> PgNpK (il_value i) _ -> pprPanic "patGroup NPlusKPat" (ppr oval) patGroup _ (CoPat _ p _) = PgCo (hsPatType p) -- Type of innelexp pattern patGroup _ (ViewPat expr p _) = PgView expr (hsPatType (unLoc p))
deSugar/Match.hs-boot view
@@ -1,10 +1,13 @@ module Match where++import GhcPrelude import Var ( Id ) import TcType ( Type ) import DsMonad ( DsM, EquationInfo, MatchResult ) import CoreSyn ( CoreExpr ) import HsSyn ( LPat, HsMatchContext, MatchGroup, LHsExpr ) import Name ( Name )+import HsExtension ( GhcTc ) match :: [Id] -> Type@@ -13,14 +16,14 @@ matchWrapper :: HsMatchContext Name- -> Maybe (LHsExpr Id)- -> MatchGroup Id (LHsExpr Id)+ -> Maybe (LHsExpr GhcTc)+ -> MatchGroup GhcTc (LHsExpr GhcTc) -> DsM ([Id], CoreExpr) matchSimply :: CoreExpr -> HsMatchContext Name- -> LPat Id+ -> LPat GhcTc -> CoreExpr -> CoreExpr -> DsM CoreExpr@@ -28,7 +31,7 @@ matchSinglePat :: CoreExpr -> HsMatchContext Name- -> LPat Id+ -> LPat GhcTc -> Type -> MatchResult -> DsM MatchResult
deSugar/MatchCon.hs view
@@ -7,11 +7,14 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module MatchCon ( matchConFamily, matchPatSyn ) where #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} Match ( match ) import HsSyn@@ -22,7 +25,6 @@ import DsUtils import MkCore ( mkCoreLets ) import Util-import ListSetOps ( runs ) import Id import NameEnv import FieldLabel ( flSelector )@@ -30,6 +32,7 @@ import DynFlags import Outputable import Control.Monad(liftM)+import Data.List (groupBy) {- We are confronted with the first column of patterns in a set of@@ -112,7 +115,7 @@ _ -> panic "matchPatSyn: not PatSynCon" matchPatSyn _ _ _ = panic "matchPatSyn []" -type ConArgPats = HsConDetails (LPat Id) (HsRecFields Id (LPat Id))+type ConArgPats = HsConDetails (LPat GhcTc) (HsRecFields GhcTc (LPat GhcTc)) matchOneConLike :: [Id] -> Type@@ -153,8 +156,8 @@ -- Divide into sub-groups; see Note [Record patterns] ; let groups :: [[(ConArgPats, EquationInfo)]]- groups = runs compatible_pats [ (pat_args (firstPat eqn), eqn)- | eqn <- eqn1:eqns ]+ groups = groupBy compatible_pats [ (pat_args (firstPat eqn), eqn)+ | eqn <- eqn1:eqns ] ; match_results <- mapM (match_group arg_vars) groups @@ -177,7 +180,7 @@ | RecCon flds <- arg_pats , let rpats = rec_flds flds , not (null rpats) -- Treated specially; cf conArgPats- = ASSERT2( length fields1 == length arg_vars,+ = ASSERT2( fields1 `equalLength` arg_vars, ppr con1 $$ ppr fields1 $$ ppr arg_vars ) map lookup_fld rpats | otherwise@@ -198,7 +201,8 @@ compatible_pats _ (RecCon flds2, _) = null (rec_flds flds2) compatible_pats _ _ = True -- Prefix or infix con -same_fields :: HsRecFields Id (LPat Id) -> HsRecFields Id (LPat Id) -> Bool+same_fields :: HsRecFields GhcTc (LPat GhcTc) -> HsRecFields GhcTc (LPat GhcTc)+ -> Bool same_fields flds1 flds2 = all2 (\(L _ f1) (L _ f2) -> unLoc (hsRecFieldId f1) == unLoc (hsRecFieldId f2))@@ -215,7 +219,7 @@ -- Used only to fill in the types of WildPats, which -- are probably never looked at anyway -> ConArgPats- -> [Pat Id]+ -> [Pat GhcTc] conArgPats _arg_tys (PrefixCon ps) = map unLoc ps conArgPats _arg_tys (InfixCon p1 p2) = [unLoc p1, unLoc p2] conArgPats arg_tys (RecCon (HsRecFields { rec_flds = rpats }))@@ -245,7 +249,7 @@ In the first we must test y first; in the second we must test x first. So we must divide even the equations for a single constructor T into sub-goups, based on whether they match the same field in the-same order. That's what the (runs compatible_pats) grouping.+same order. That's what the (groupBy compatible_pats) grouping. All non-record patterns are "compatible" in this sense, because the positional patterns (T a b) and (a `T` b) all match the arguments
deSugar/MatchLit.hs view
@@ -17,6 +17,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} Match ( match ) import {-# SOURCE #-} DsExpr ( dsExpr, dsSyntaxExpr ) @@ -49,6 +51,7 @@ import Control.Monad import Data.Int import Data.Word+import Data.Proxy {- ************************************************************************@@ -73,26 +76,25 @@ See also below where we look for @DictApps@ for \tr{plusInt}, etc. -} -dsLit :: HsLit -> DsM CoreExpr+dsLit :: HsLit GhcRn -> DsM CoreExpr dsLit (HsStringPrim _ s) = return (Lit (MachStr s)) dsLit (HsCharPrim _ c) = return (Lit (MachChar c)) dsLit (HsIntPrim _ i) = return (Lit (MachInt i)) dsLit (HsWordPrim _ w) = return (Lit (MachWord w)) dsLit (HsInt64Prim _ i) = return (Lit (MachInt64 i)) dsLit (HsWord64Prim _ w) = return (Lit (MachWord64 w))-dsLit (HsFloatPrim f) = return (Lit (MachFloat (fl_value f)))-dsLit (HsDoublePrim d) = return (Lit (MachDouble (fl_value d)))-+dsLit (HsFloatPrim _ f) = return (Lit (MachFloat (fl_value f)))+dsLit (HsDoublePrim _ d) = return (Lit (MachDouble (fl_value d))) dsLit (HsChar _ c) = return (mkCharExpr c) dsLit (HsString _ str) = mkStringExprFS str dsLit (HsInteger _ i _) = mkIntegerExpr i dsLit (HsInt _ i) = do dflags <- getDynFlags- return (mkIntExpr dflags i)+ return (mkIntExpr dflags (il_value i)) -dsLit (HsRat r ty) = do- num <- mkIntegerExpr (numerator (fl_value r))- denom <- mkIntegerExpr (denominator (fl_value r))- return (mkCoreConApps ratio_data_con [Type integer_ty, num, denom])+dsLit (HsRat _ (FL _ _ val) ty) = do+ num <- mkIntegerExpr (numerator val)+ denom <- mkIntegerExpr (denominator val)+ return (mkCoreConApps ratio_data_con [Type integer_ty, num, denom]) where (ratio_data_con, integer_ty) = case tcSplitTyConApp ty of@@ -100,12 +102,12 @@ (head (tyConDataCons tycon), i_ty) x -> pprPanic "dsLit" (ppr x) -dsOverLit :: HsOverLit Id -> DsM CoreExpr+dsOverLit :: HsOverLit GhcTc -> DsM CoreExpr dsOverLit lit = do { dflags <- getDynFlags ; warnAboutOverflowedLiterals dflags lit ; dsOverLit' dflags lit } -dsOverLit' :: DynFlags -> HsOverLit Id -> DsM CoreExpr+dsOverLit' :: DynFlags -> HsOverLit GhcTc -> DsM CoreExpr -- Post-typechecker, the HsExpr field of an OverLit contains -- (an expression for) the literal value itself dsOverLit' dflags (OverLit { ol_val = val, ol_rebindable = rebindable@@ -153,25 +155,25 @@ -- We can't easily add fromIntegerName, fromRationalName, -- because they are generated by literals -warnAboutOverflowedLiterals :: DynFlags -> HsOverLit Id -> DsM ()+warnAboutOverflowedLiterals :: DynFlags -> HsOverLit GhcTc -> DsM () warnAboutOverflowedLiterals dflags lit | wopt Opt_WarnOverflowedLiterals dflags , Just (i, tc) <- getIntegralLit lit- = if tc == intTyConName then check i tc (undefined :: Int)- else if tc == int8TyConName then check i tc (undefined :: Int8)- else if tc == int16TyConName then check i tc (undefined :: Int16)- else if tc == int32TyConName then check i tc (undefined :: Int32)- else if tc == int64TyConName then check i tc (undefined :: Int64)- else if tc == wordTyConName then check i tc (undefined :: Word)- else if tc == word8TyConName then check i tc (undefined :: Word8)- else if tc == word16TyConName then check i tc (undefined :: Word16)- else if tc == word32TyConName then check i tc (undefined :: Word32)- else if tc == word64TyConName then check i tc (undefined :: Word64)+ = if tc == intTyConName then check i tc (Proxy :: Proxy Int)+ else if tc == int8TyConName then check i tc (Proxy :: Proxy Int8)+ else if tc == int16TyConName then check i tc (Proxy :: Proxy Int16)+ else if tc == int32TyConName then check i tc (Proxy :: Proxy Int32)+ else if tc == int64TyConName then check i tc (Proxy :: Proxy Int64)+ else if tc == wordTyConName then check i tc (Proxy :: Proxy Word)+ else if tc == word8TyConName then check i tc (Proxy :: Proxy Word8)+ else if tc == word16TyConName then check i tc (Proxy :: Proxy Word16)+ else if tc == word32TyConName then check i tc (Proxy :: Proxy Word32)+ else if tc == word64TyConName then check i tc (Proxy :: Proxy Word64) else return () | otherwise = return () where- check :: forall a. (Bounded a, Integral a) => Integer -> Name -> a -> DsM ()+ check :: forall a. (Bounded a, Integral a) => Integer -> Name -> Proxy a -> DsM () check i tc _proxy = when (i < minB || i > maxB) $ do warnDs (Reason Opt_WarnOverflowedLiterals)@@ -200,7 +202,8 @@ but perhaps that does not matter too much. -} -warnAboutEmptyEnumerations :: DynFlags -> LHsExpr Id -> Maybe (LHsExpr Id) -> LHsExpr Id -> DsM ()+warnAboutEmptyEnumerations :: DynFlags -> LHsExpr GhcTc -> Maybe (LHsExpr GhcTc)+ -> LHsExpr GhcTc -> DsM () -- Warns about [2,3 .. 1] which returns the empty list -- Only works for integral types, not floating point warnAboutEmptyEnumerations dflags fromExpr mThnExpr toExpr@@ -208,7 +211,7 @@ , Just (from,tc) <- getLHsIntegralLit fromExpr , Just mThn <- traverse getLHsIntegralLit mThnExpr , Just (to,_) <- getLHsIntegralLit toExpr- , let check :: forall a. (Enum a, Num a) => a -> DsM ()+ , let check :: forall a. (Enum a, Num a) => Proxy a -> DsM () check _proxy = when (null enumeration) $ warnDs (Reason Opt_WarnEmptyEnumerations) (text "Enumeration is empty")@@ -218,22 +221,22 @@ Nothing -> [fromInteger from .. fromInteger to] Just (thn,_) -> [fromInteger from, fromInteger thn .. fromInteger to] - = if tc == intTyConName then check (undefined :: Int)- else if tc == int8TyConName then check (undefined :: Int8)- else if tc == int16TyConName then check (undefined :: Int16)- else if tc == int32TyConName then check (undefined :: Int32)- else if tc == int64TyConName then check (undefined :: Int64)- else if tc == wordTyConName then check (undefined :: Word)- else if tc == word8TyConName then check (undefined :: Word8)- else if tc == word16TyConName then check (undefined :: Word16)- else if tc == word32TyConName then check (undefined :: Word32)- else if tc == word64TyConName then check (undefined :: Word64)- else if tc == integerTyConName then check (undefined :: Integer)+ = if tc == intTyConName then check (Proxy :: Proxy Int)+ else if tc == int8TyConName then check (Proxy :: Proxy Int8)+ else if tc == int16TyConName then check (Proxy :: Proxy Int16)+ else if tc == int32TyConName then check (Proxy :: Proxy Int32)+ else if tc == int64TyConName then check (Proxy :: Proxy Int64)+ else if tc == wordTyConName then check (Proxy :: Proxy Word)+ else if tc == word8TyConName then check (Proxy :: Proxy Word8)+ else if tc == word16TyConName then check (Proxy :: Proxy Word16)+ else if tc == word32TyConName then check (Proxy :: Proxy Word32)+ else if tc == word64TyConName then check (Proxy :: Proxy Word64)+ else if tc == integerTyConName then check (Proxy :: Proxy Integer) else return () | otherwise = return () -getLHsIntegralLit :: LHsExpr Id -> Maybe (Integer, Name)+getLHsIntegralLit :: LHsExpr GhcTc -> Maybe (Integer, Name) -- See if the expression is an Integral literal -- Remember to look through automatically-added tick-boxes! (Trac #8384) getLHsIntegralLit (L _ (HsPar e)) = getLHsIntegralLit e@@ -242,10 +245,10 @@ getLHsIntegralLit (L _ (HsOverLit over_lit)) = getIntegralLit over_lit getLHsIntegralLit _ = Nothing -getIntegralLit :: HsOverLit Id -> Maybe (Integer, Name)-getIntegralLit (OverLit { ol_val = HsIntegral _ i, ol_type = ty })+getIntegralLit :: HsOverLit GhcTc -> Maybe (Integer, Name)+getIntegralLit (OverLit { ol_val = HsIntegral i, ol_type = ty }) | Just tc <- tyConAppTyCon_maybe ty- = Just (i, tyConName tc)+ = Just (il_value i, tyConName tc) getIntegralLit _ = Nothing {-@@ -256,7 +259,7 @@ ************************************************************************ -} -tidyLitPat :: HsLit -> Pat Id+tidyLitPat :: HsLit GhcTc -> Pat GhcTc -- Result has only the following HsLits: -- HsIntPrim, HsWordPrim, HsCharPrim, HsFloatPrim -- HsDoublePrim, HsStringPrim, HsString@@ -273,13 +276,14 @@ tidyLitPat lit = LitPat lit -----------------tidyNPat :: (HsLit -> Pat Id) -- How to tidy a LitPat+tidyNPat :: (HsLit GhcTc -> Pat GhcTc) -- How to tidy a LitPat -- We need this argument because tidyNPat is called -- both by Match and by Check, but they tidy LitPats -- slightly differently; and we must desugar -- literals consistently (see Trac #5117)- -> HsOverLit Id -> Maybe (SyntaxExpr Id) -> SyntaxExpr Id -> Type- -> Pat Id+ -> HsOverLit GhcTc -> Maybe (SyntaxExpr GhcTc) -> SyntaxExpr GhcTc+ -> Type+ -> Pat GhcTc tidyNPat tidy_lit_pat (OverLit val False _ ty) mb_neg _eq outer_ty -- False: Take short cuts only if the literal is not using rebindable syntax --@@ -308,13 +312,13 @@ -- type family Id). In these cases, we can't do the short-cut. type_change = not (outer_ty `eqType` ty) - mk_con_pat :: DataCon -> HsLit -> Pat Id+ mk_con_pat :: DataCon -> HsLit GhcTc -> Pat GhcTc mk_con_pat con lit = unLoc (mkPrefixConPat con [noLoc $ LitPat lit] []) mb_int_lit :: Maybe Integer mb_int_lit = case (mb_neg, val) of- (Nothing, HsIntegral _ i) -> Just i- (Just _, HsIntegral _ i) -> Just (-i)+ (Nothing, HsIntegral i) -> Just (il_value i)+ (Just _, HsIntegral i) -> Just (-(il_value i)) _ -> Nothing mb_str_lit :: Maybe FastString@@ -375,7 +379,7 @@ matchLiterals [] _ _ = panic "matchLiterals []" ----------------------------hsLitKey :: DynFlags -> HsLit -> Literal+hsLitKey :: DynFlags -> HsLit GhcTc -> Literal -- Get the Core literal corresponding to a HsLit. -- It only works for primitive types and strings; -- others have been removed by tidy@@ -390,8 +394,8 @@ hsLitKey _ (HsInt64Prim _ i) = mkMachInt64Wrap i hsLitKey _ (HsWord64Prim _ w) = mkMachWord64Wrap w hsLitKey _ (HsCharPrim _ c) = mkMachChar c-hsLitKey _ (HsFloatPrim f) = mkMachFloat (fl_value f)-hsLitKey _ (HsDoublePrim d) = mkMachDouble (fl_value d)+hsLitKey _ (HsFloatPrim _ f) = mkMachFloat (fl_value f)+hsLitKey _ (HsDoublePrim _ d) = mkMachDouble (fl_value d) hsLitKey _ (HsString _ s) = MachStr (fastStringToByteString s) hsLitKey _ l = pprPanic "hsLitKey" (ppr l)
deSugar/PmExpr.hs view
@@ -15,6 +15,8 @@ #include "HsVersions.h" +import GhcPrelude+ import HsSyn import Id import Name@@ -56,15 +58,15 @@ | PmExprCon ConLike [PmExpr] | PmExprLit PmLit | PmExprEq PmExpr PmExpr -- Syntactic equality- | PmExprOther (HsExpr Id) -- Note [PmExprOther in PmExpr]+ | PmExprOther (HsExpr GhcTc) -- Note [PmExprOther in PmExpr] mkPmExprData :: DataCon -> [PmExpr] -> PmExpr mkPmExprData dc args = PmExprCon (RealDataCon dc) args -- | Literals (simple and overloaded ones) for pattern match checking.-data PmLit = PmSLit HsLit -- simple- | PmOLit Bool {- is it negated? -} (HsOverLit Id) -- overloaded+data PmLit = PmSLit (HsLit GhcTc) -- simple+ | PmOLit Bool {- is it negated? -} (HsOverLit GhcTc) -- overloaded -- | Equality between literals for pattern match checking. eqPmLit :: PmLit -> PmLit -> Bool@@ -229,10 +231,10 @@ -- ----------------------------------------------------------------------- -- ** Lift source expressions (HsExpr Id) to PmExpr -lhsExprToPmExpr :: LHsExpr Id -> PmExpr+lhsExprToPmExpr :: LHsExpr GhcTc -> PmExpr lhsExprToPmExpr (L _ e) = hsExprToPmExpr e -hsExprToPmExpr :: HsExpr Id -> PmExpr+hsExprToPmExpr :: HsExpr GhcTc -> PmExpr hsExprToPmExpr (HsVar x) = PmExprVar (idName (unLoc x)) hsExprToPmExpr (HsConLikeOut c) = PmExprVar (conLikeName c)@@ -282,7 +284,7 @@ hsExprToPmExpr (HsWrap _ e) = hsExprToPmExpr e hsExprToPmExpr e = PmExprOther e -- the rest are not handled by the oracle -synExprToPmExpr :: SyntaxExpr Id -> PmExpr+synExprToPmExpr :: SyntaxExpr GhcTc -> PmExpr synExprToPmExpr = hsExprToPmExpr . syn_expr -- ignore the wrappers {-
deSugar/TmOracle.hs view
@@ -22,6 +22,8 @@ #include "HsVersions.h" +import GhcPrelude+ import PmExpr import Id
dist/build/CmmLex.hs view
@@ -13,6 +13,8 @@ CmmToken(..), cmmlex, ) where +import GhcPrelude+ import CmmExpr import Lexer@@ -377,7 +379,7 @@ , (0,alex_action_39) ] -{-# LINE 127 "cmm/CmmLex.x" #-}+{-# LINE 129 "cmm/CmmLex.x" #-} data CmmToken = CmmT_SpecChar Char
dist/build/CmmParse.hs view
@@ -5,6 +5,8 @@ #endif module CmmParse ( parseCmmFile ) where +import GhcPrelude+ import StgCmmExtCode import CmmCallConv import StgCmmProf@@ -2715,6 +2717,7 @@ ( "memcpy", memcpyLikeTweakArgs MO_Memcpy ), ( "memset", memcpyLikeTweakArgs MO_Memset ), ( "memmove", memcpyLikeTweakArgs MO_Memmove ),+ ( "memcmp", memcpyLikeTweakArgs MO_Memcmp ), ("prefetch0", (,) $ MO_Prefetch_Data 0), ("prefetch1", (,) $ MO_Prefetch_Data 1),@@ -2726,6 +2729,16 @@ ( "popcnt32", (,) $ MO_PopCnt W32 ), ( "popcnt64", (,) $ MO_PopCnt W64 ), + ( "pdep8", (,) $ MO_Pdep W8 ),+ ( "pdep16", (,) $ MO_Pdep W16 ),+ ( "pdep32", (,) $ MO_Pdep W32 ),+ ( "pdep64", (,) $ MO_Pdep W64 ),++ ( "pext8", (,) $ MO_Pext W8 ),+ ( "pext16", (,) $ MO_Pext W16 ),+ ( "pext32", (,) $ MO_Pext W32 ),+ ( "pext64", (,) $ MO_Pext W64 ),+ ( "cmpxchg8", (,) $ MO_Cmpxchg W8 ), ( "cmpxchg16", (,) $ MO_Cmpxchg W16 ), ( "cmpxchg32", (,) $ MO_Cmpxchg W32 ),@@ -3126,9 +3139,11 @@ -- reset the lex_state: the Lexer monad leaves some stuff -- in there we don't want. case unPD cmmParse dflags init_state of- PFailed span err -> do+ PFailed warnFn span err -> do let msg = mkPlainErrMsg dflags span err- return ((emptyBag, unitBag msg), Nothing)+ errMsgs = (emptyBag, unitBag msg)+ warnMsgs = warnFn dflags+ return (unionMessages warnMsgs errMsgs, Nothing) POk pst code -> do st <- initC let fcode = getCmm $ unEC code "global" (initEnv dflags) [] >> return ()
dist/build/Lexer.hs view
@@ -36,19 +36,19 @@ moveAnnotations ) where +import GhcPrelude+ -- base import Control.Monad-#if __GLASGOW_HASKELL__ > 710-import Control.Monad.Fail-#endif+import Control.Monad.Fail as MonadFail import Data.Bits import Data.Char import Data.List import Data.Maybe import Data.Word -import Data.IntSet (IntSet)-import qualified Data.IntSet as IntSet+import EnumSet (EnumSet)+import qualified EnumSet -- ghc-boot import qualified GHC.LanguageExtensions as LangExt@@ -66,7 +66,7 @@ import StringBuffer import FastString import UniqFM-import Util ( readRational )+import Util ( readRational, readHexRational ) -- compiler/main import ErrUtils@@ -75,7 +75,8 @@ -- compiler/basicTypes import SrcLoc import Module-import BasicTypes ( InlineSpec(..), RuleMatchInfo(..), FractionalLit(..),+import BasicTypes ( InlineSpec(..), RuleMatchInfo(..),+ IntegralLit(..), FractionalLit(..), SourceText(..) ) -- compiler/parser@@ -103,31 +104,33 @@ alex_tab_size = 8 alex_base :: AlexAddr alex_base = AlexA#- "\x01\x00\x00\x00\x7b\x00\x00\x00\x84\x00\x00\x00\xa0\x00\x00\x00\xbc\x00\x00\x00\xc5\x00\x00\x00\xce\x00\x00\x00\xec\x00\x00\x00\x06\x01\x00\x00\x0b\x01\x00\x00\x06\x02\x00\x00\x20\x02\x00\x00\x25\x02\x00\x00\x62\x02\x00\x00\xd4\xff\xff\xff\x61\x00\x00\x00\xd7\xff\xff\xff\xdb\xff\xff\xff\xa4\xff\xff\xff\xaa\xff\xff\xff\xdf\x02\x00\x00\x59\x03\x00\x00\xd3\x03\x00\x00\x93\xff\xff\xff\x94\xff\xff\xff\x4d\x04\x00\x00\x95\xff\xff\xff\x48\x04\x00\x00\xc8\x04\x00\x00\x48\x05\x00\x00\xc8\x05\x00\x00\x48\x06\x00\x00\xb2\xff\xff\xff\xc8\x06\x00\x00\xe7\xff\xff\xff\xe8\xff\xff\xff\xe9\xff\xff\xff\x48\x07\x00\x00\xc8\x07\x00\x00\x48\x08\x00\x00\xc8\x08\x00\x00\x48\x09\x00\x00\xae\xff\xff\xff\xc8\x09\x00\x00\xab\xff\xff\xff\x48\x0a\x00\x00\xb0\xff\xff\xff\xc8\x0a\x00\x00\x22\x01\x00\x00\x41\x01\x00\x00\x48\x0b\x00\x00\xb3\xff\xff\xff\xc8\x0b\x00\x00\xba\xff\xff\xff\xac\xff\xff\xff\x00\x00\x00\x00\x39\x0c\x00\x00\x00\x00\x00\x00\xaa\x0c\x00\x00\xa9\x0d\x00\x00\x00\x00\x00\x00\x95\x0d\x00\x00\x00\x00\x00\x00\xd6\x0d\x00\x00\x00\x00\x00\x00\x17\x0e\x00\x00\x00\x00\x00\x00\x88\x0e\x00\x00\x00\x00\x00\x00\xf9\x0e\x00\x00\x00\x00\x00\x00\x6a\x0f\x00\x00\x00\x00\x00\x00\xdb\x0f\x00\x00\x00\x00\x00\x00\x4c\x10\x00\x00\x4b\x11\x00\x00\x00\x00\x00\x00\x07\x11\x00\x00\xaf\xff\xff\xff\x07\x12\x00\x00\xc7\x11\x00\x00\x00\x00\x00\x00\xc7\x12\x00\x00\x87\x12\x00\x00\x00\x00\x00\x00\xb1\xff\xff\xff\x00\x00\x00\x00\xc8\x12\x00\x00\x00\x00\x00\x00\x09\x13\x00\x00\x00\x00\x00\x00\x4a\x13\x00\x00\x00\x00\x00\x00\x8b\x13\x00\x00\x00\x00\x00\x00\xcc\x13\x00\x00\xd1\x00\x00\x00\x1f\x01\x00\x00\xe4\x01\x00\x00\x23\x02\x00\x00\x40\x02\x00\x00\x60\x02\x00\x00\x82\x0d\x00\x00\x62\x00\x00\x00\x51\x00\x00\x00\x1e\x11\x00\x00\x29\x01\x00\x00\x5a\x00\x00\x00\xcb\x14\x00\x00\x25\x15\x00\x00\xa3\x15\x00\x00\x1f\x16\x00\x00\x9b\x16\x00\x00\x17\x17\x00\x00\x93\x17\x00\x00\x0f\x18\x00\x00\x78\x00\x00\x00\x8b\x18\x00\x00\x0a\x19\x00\x00\xca\x18\x00\x00\x00\x00\x00\x00\xc9\x19\x00\x00\xc8\x19\x00\x00\xbe\x1a\x00\x00\xbe\x1b\x00\x00\x09\x1a\x00\x00\x00\x00\x00\x00\x3e\x1c\x00\x00\xfe\x1b\x00\x00\x00\x00\x00\x00\xfe\x1c\x00\x00\xbe\x1c\x00\x00\x00\x00\x00\x00\xbe\x1d\x00\x00\x7e\x1d\x00\x00\x00\x00\x00\x00\x7e\x1e\x00\x00\x3e\x1e\x00\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x39\x1f\x00\x00\x00\x00\x00\x00\x2f\x20\x00\x00\xe1\x02\x00\x00\x5b\x03\x00\x00\xf9\xff\xff\xff\x25\x21\x00\x00\x1b\x22\x00\x00\x11\x23\x00\x00\x07\x24\x00\x00\xfd\x24\x00\x00\xf3\x25\x00\x00\xe9\x26\x00\x00\xe5\x27\x00\x00\xe1\x28\x00\x00\xdd\x29\x00\x00\xd9\x2a\x00\x00\xd5\x2b\x00\x00\xd1\x2c\x00\x00\xcd\x2d\x00\x00\xc3\x2e\x00\x00\xb9\x2f\x00\x00\xaf\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x1f\x00\x00\xaf\x31\x00\x00\xa3\x32\x00\x00\x1d\x33\x00\x00\xbd\x02\x00\x00\x97\x33\x00\x00\x0c\x34\x00\x00\x02\x35\x00\x00\x02\x36\x00\x00\x78\x36\x00\x00\x37\x03\x00\x00\x77\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x37\x00\x00\x00\x00\x00\x00\x6f\x38\x00\x00\xe9\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\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\x63\x39\x00\x00\xdd\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x3a\x00\x00\xf1\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\xc7\x3b\x00\x00\x41\x3c\x00\x00\xbb\x3c\x00\x00\x35\x3d\x00\x00\xaf\x3d\x00\x00\x29\x3e\x00\x00\xa3\x3e\x00\x00\x1d\x3f\x00\x00\x80\x00\x00\x00\x83\x00\x00\x00\x8b\x00\x00\x00\x8c\x00\x00\x00\x77\x3f\x00\x00\x9a\x3f\x00\x00\xf6\x3f\x00\x00\x19\x40\x00\x00\x3c\x40\x00\x00\x64\x40\x00\x00\xa7\x40\x00\x00\xcc\x40\x00\x00\x45\x41\x00\x00\xbe\x41\x00\x00\x37\x42\x00\x00\x93\x42\x00\x00\xb8\x42\x00\x00\xc9\x03\x00\x00\x17\x20\x00\x00\x9b\x00\x00\x00\x2e\x04\x00\x00\x7d\x15\x00\x00\x43\x04\x00\x00\x0d\x21\x00\x00\xb1\x00\x00\x00\x35\x11\x00\x00\x03\x22\x00\x00\xc3\x14\x00\x00\xab\x14\x00\x00\x34\x1f\x00\x00\xb7\x14\x00\x00\x8d\x00\x00\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#+ "\x01\x00\x00\x00\x7b\x00\x00\x00\x84\x00\x00\x00\xa0\x00\x00\x00\xbc\x00\x00\x00\xc5\x00\x00\x00\xce\x00\x00\x00\xec\x00\x00\x00\x06\x01\x00\x00\x0b\x01\x00\x00\x06\x02\x00\x00\x20\x02\x00\x00\x25\x02\x00\x00\x62\x02\x00\x00\xd4\xff\xff\xff\x61\x00\x00\x00\xd7\xff\xff\xff\xdb\xff\xff\xff\xa4\xff\xff\xff\xaa\xff\xff\xff\xdf\x02\x00\x00\x59\x03\x00\x00\xd3\x03\x00\x00\x93\xff\xff\xff\x94\xff\xff\xff\x4d\x04\x00\x00\x95\xff\xff\xff\x48\x04\x00\x00\xc8\x04\x00\x00\x48\x05\x00\x00\xc8\x05\x00\x00\x48\x06\x00\x00\xb2\xff\xff\xff\xc8\x06\x00\x00\xe7\xff\xff\xff\xe8\xff\xff\xff\xe9\xff\xff\xff\x48\x07\x00\x00\xc8\x07\x00\x00\x48\x08\x00\x00\xc8\x08\x00\x00\x48\x09\x00\x00\xae\xff\xff\xff\xc8\x09\x00\x00\xab\xff\xff\xff\x48\x0a\x00\x00\xb0\xff\xff\xff\xc8\x0a\x00\x00\x22\x01\x00\x00\x41\x01\x00\x00\x48\x0b\x00\x00\xb3\xff\xff\xff\xc8\x0b\x00\x00\xba\xff\xff\xff\xac\xff\xff\xff\x00\x00\x00\x00\x39\x0c\x00\x00\x00\x00\x00\x00\xaa\x0c\x00\x00\xa9\x0d\x00\x00\x00\x00\x00\x00\x95\x0d\x00\x00\x00\x00\x00\x00\xd6\x0d\x00\x00\x00\x00\x00\x00\x17\x0e\x00\x00\x00\x00\x00\x00\x88\x0e\x00\x00\x00\x00\x00\x00\xf9\x0e\x00\x00\x00\x00\x00\x00\x6a\x0f\x00\x00\x00\x00\x00\x00\xdb\x0f\x00\x00\x00\x00\x00\x00\x4c\x10\x00\x00\x4b\x11\x00\x00\x00\x00\x00\x00\x07\x11\x00\x00\xaf\xff\xff\xff\x07\x12\x00\x00\xc7\x11\x00\x00\x00\x00\x00\x00\xc7\x12\x00\x00\x87\x12\x00\x00\x00\x00\x00\x00\xb1\xff\xff\xff\x00\x00\x00\x00\xc8\x12\x00\x00\x00\x00\x00\x00\x09\x13\x00\x00\x00\x00\x00\x00\x4a\x13\x00\x00\x00\x00\x00\x00\x8b\x13\x00\x00\x00\x00\x00\x00\xcc\x13\x00\x00\x82\x0d\x00\x00\xd1\x00\x00\x00\x1f\x01\x00\x00\x1e\x11\x00\x00\xe9\x01\x00\x00\x23\x02\x00\x00\x45\x02\x00\x00\x60\x02\x00\x00\xbd\x02\x00\x00\xd0\x02\x00\x00\x37\x03\x00\x00\x4a\x03\x00\x00\x9c\x14\x00\x00\x62\x00\x00\x00\x51\x00\x00\x00\xb3\x14\x00\x00\x29\x01\x00\x00\x5a\x00\x00\x00\xd9\x14\x00\x00\x33\x15\x00\x00\xb1\x15\x00\x00\x2d\x16\x00\x00\xa9\x16\x00\x00\x25\x17\x00\x00\xa1\x17\x00\x00\x1d\x18\x00\x00\x78\x00\x00\x00\x99\x18\x00\x00\x18\x19\x00\x00\xd8\x18\x00\x00\x00\x00\x00\x00\xd7\x19\x00\x00\xd6\x19\x00\x00\xcc\x1a\x00\x00\xcc\x1b\x00\x00\x17\x1a\x00\x00\x00\x00\x00\x00\x4c\x1c\x00\x00\x0c\x1c\x00\x00\x00\x00\x00\x00\x0c\x1d\x00\x00\xcc\x1c\x00\x00\x00\x00\x00\x00\xcc\x1d\x00\x00\x8c\x1d\x00\x00\x00\x00\x00\x00\x8c\x1e\x00\x00\x4c\x1e\x00\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x47\x1f\x00\x00\x00\x00\x00\x00\x3d\x20\x00\x00\x26\x02\x00\x00\xd5\x03\x00\x00\xf9\xff\xff\xff\x33\x21\x00\x00\x29\x22\x00\x00\x1f\x23\x00\x00\x15\x24\x00\x00\x0b\x25\x00\x00\x01\x26\x00\x00\xf7\x26\x00\x00\xf3\x27\x00\x00\xef\x28\x00\x00\xeb\x29\x00\x00\xe7\x2a\x00\x00\xe3\x2b\x00\x00\xdf\x2c\x00\x00\xdb\x2d\x00\x00\xd1\x2e\x00\x00\xc7\x2f\x00\x00\xbd\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x1f\x00\x00\xbd\x31\x00\x00\xb1\x32\x00\x00\x2b\x33\x00\x00\xb1\x03\x00\x00\xa5\x33\x00\x00\x1a\x34\x00\x00\x10\x35\x00\x00\x10\x36\x00\x00\x86\x36\x00\x00\x2b\x04\x00\x00\x85\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x38\x00\x00\x00\x00\x00\x00\x7d\x38\x00\x00\xf7\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\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\x71\x39\x00\x00\xeb\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x3a\x00\x00\xff\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\xd5\x3b\x00\x00\x4f\x3c\x00\x00\xc9\x3c\x00\x00\x43\x3d\x00\x00\xbd\x3d\x00\x00\x37\x3e\x00\x00\xb1\x3e\x00\x00\x2b\x3f\x00\x00\x80\x00\x00\x00\x83\x00\x00\x00\x8b\x00\x00\x00\x8c\x00\x00\x00\x85\x3f\x00\x00\xa8\x3f\x00\x00\x04\x40\x00\x00\x27\x40\x00\x00\x4a\x40\x00\x00\x72\x40\x00\x00\xb5\x40\x00\x00\xda\x40\x00\x00\x53\x41\x00\x00\xcc\x41\x00\x00\x45\x42\x00\x00\xa1\x42\x00\x00\xc6\x42\x00\x00\x43\x04\x00\x00\x25\x20\x00\x00\x9b\x00\x00\x00\x35\x11\x00\x00\x1b\x21\x00\x00\x8b\x15\x00\x00\x11\x22\x00\x00\xb1\x00\x00\x00\xd7\x14\x00\x00\x41\x21\x00\x00\x42\x1f\x00\x00\x09\x16\x00\x00\x07\x23\x00\x00\x13\x16\x00\x00\x11\x23\x00\x00\x3d\x11\x00\x00\xf0\x23\x00\x00\x95\x15\x00\x00\x8d\x00\x00\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# alex_table :: AlexAddr alex_table = AlexA#- "\x00\x00\x92\x00\xed\x00\xeb\x00\x9b\x00\xf9\x00\x8c\x00\xd3\x00\x9c\x00\xa5\x00\x8e\x00\xae\x00\x8c\x00\x8c\x00\x8c\x00\xab\x00\xbb\x00\xbc\x00\xbe\x00\x7c\x00\x17\x00\x18\x00\x1a\x00\x56\x00\x20\x00\x4f\x00\x2c\x00\x33\x00\x14\x00\x13\x00\x35\x00\x12\x00\x92\x00\x8c\x00\xf9\x00\x1d\x01\xfa\x00\xfd\x00\xf9\x00\xf9\x00\x1c\x01\xdc\x00\xdd\x00\xf9\x00\xf9\x00\xe1\x00\xf5\x00\xf9\x00\xf9\x00\x01\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xfe\x00\xe2\x00\xf9\x00\xf9\x00\xf9\x00\xfb\x00\xd4\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xdf\x00\xf9\x00\xe0\x00\xf9\x00\xeb\x00\xe3\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xe5\x00\xf7\x00\xe6\x00\xf9\x00\x8c\x00\x07\x01\x07\x01\x2e\x00\x8e\x00\xa4\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x02\x01\x02\x01\xc5\x00\x8e\x00\x9c\x00\x8c\x00\x8c\x00\x8c\x00\x08\x01\x08\x01\x08\x01\x08\x01\x08\x01\x08\x01\x08\x01\x08\x01\xc7\x00\x8c\x00\xc1\x00\x90\x00\xa6\x00\x91\x00\x7b\x00\xd9\x00\xc1\x00\xef\x00\x8c\x00\x8c\x00\xf0\x00\x00\x00\x11\x00\x8e\x00\xaa\x00\x8c\x00\x8c\x00\x8c\x00\xf1\x00\xf2\x00\x16\x01\x11\x00\x17\x01\x18\x01\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x0f\x01\x19\x01\x8c\x00\x8c\x00\x1b\x01\xac\x00\x00\x00\x8e\x00\xaa\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x02\x01\x02\x01\x11\x00\x8e\x00\xaa\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x13\x01\x00\x00\xc1\x00\x8e\x00\x00\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x00\x00\xbb\x00\xac\x00\x00\x00\x07\x01\x07\x01\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\xac\x00\x11\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x8c\x00\x36\x00\x00\x00\x8c\x00\x11\x00\x00\x00\xc1\x00\x8e\x00\x0e\x00\x8c\x00\x8c\x00\x8c\x00\xd5\x00\x11\x00\x62\x00\x00\x00\x62\x00\x0e\x00\x00\x00\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x8c\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8d\x00\x8c\x00\x8c\x00\x8c\x00\x8f\x00\xff\xff\x8d\x00\x8d\x00\x8d\x00\x11\x00\x00\x00\xa9\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x8c\x00\x30\x00\x7a\x00\x00\x00\x00\x00\x8d\x00\x30\x00\x30\x00\x30\x00\x30\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xad\x00\x30\x00\x00\x00\x00\x00\x23\x00\x30\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x30\x00\x30\x00\x30\x00\x30\x00\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x30\x00\x8c\x00\x00\x00\x23\x00\x00\x00\x00\x00\x0e\x00\x8c\x00\x8c\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\x00\x8c\x00\x8c\x00\x8c\x00\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8e\x00\x00\x00\x8c\x00\x8c\x00\x8c\x00\x11\x00\x00\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x8c\x00\x00\x00\x76\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x65\x00\x00\x00\x65\x00\x00\x00\x0f\x00\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\xec\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x8e\x00\xae\x00\x8c\x00\x8c\x00\x8c\x00\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x8c\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\xdd\x00\x00\x00\x00\x00\xe1\x00\x10\x00\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x00\x00\x0e\x00\x00\x00\xe2\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xde\x00\x00\x00\xe0\x00\x00\x00\xec\x00\xe3\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xe4\x00\x00\x00\xe6\x00\xaf\x00\xaf\x00\xaf\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x75\x00\x00\x00\x00\x00\xbf\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xc1\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xb1\x00\xb1\x00\xb1\x00\xc1\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x75\x00\x00\x00\x00\x00\xc0\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xc1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb2\x00\xb2\x00\xb2\x00\xc1\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x16\x00\x16\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x64\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xbd\x00\xbd\x00\xbd\x00\x10\x01\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x19\x00\x19\x00\x19\x00\x00\x00\x00\x00\x00\x00\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x12\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x61\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x80\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x1d\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x1e\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x53\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x50\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x2b\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x2d\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x6f\x00\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x14\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x08\x01\x08\x01\x08\x01\x08\x01\x08\x01\x08\x01\x08\x01\x08\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\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xea\x00\xe8\x00\x1a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x00\x00\x1a\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x0d\x01\x00\x00\x00\x00\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xe9\x00\xe7\x00\x64\x00\xf3\x00\xe8\x00\x00\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xf3\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\x00\x00\x00\x00\x00\x00\xf3\x00\xf3\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\x00\x00\xf3\x00\x00\x00\xf3\x00\xe7\x00\x00\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\x11\x01\xf3\x00\x00\x00\xf3\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\xd2\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\xd1\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\xca\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\xc9\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\xc8\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\xc6\x00\x76\x00\x76\x00\x76\x00\x76\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x76\x00\xba\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x00\x00\x7a\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7a\x00\xb4\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x51\x00\x2d\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3f\x00\x34\x00\x37\x00\x37\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x54\x00\x2b\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x41\x00\x32\x00\x39\x00\x39\x00\x39\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\xaf\x00\xaf\x00\xaf\x00\x00\x00\xff\xff\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\x0c\x01\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\x61\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\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\x0e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\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\x12\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\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\x15\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\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8a\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x87\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x84\x00\x1d\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5c\x00\x27\x00\x46\x00\x46\x00\x46\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x81\x00\x1e\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x5a\x00\x28\x00\x44\x00\x44\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x84\x00\x1d\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5c\x00\x27\x00\x46\x00\x46\x00\x46\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x9a\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x9a\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x87\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x9a\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x87\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\xb8\x00\xb8\x00\x00\x00\x9d\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\xb8\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xb8\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\xb8\x00\xb8\x00\x00\x00\x9d\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\xb8\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x87\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\x9f\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\x9f\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x87\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8a\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8a\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8a\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\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\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb0\x00\xb8\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x19\x00\x19\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\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\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x19\x00\x19\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\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\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7a\x00\xb4\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\x7a\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\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\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb7\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x14\x00\xb7\x00\xb7\x00\xb7\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb7\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb0\x00\xb8\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x79\x00\x78\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x76\x00\x76\x00\x76\x00\x76\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x76\x00\xba\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x16\x00\x16\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xce\x00\xce\x00\xce\x00\x00\x00\x00\x00\x00\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xce\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x3b\x00\x70\x00\x00\x00\x00\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x70\x00\x70\x00\x70\x00\x72\x00\x74\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x73\x00\x70\x00\x70\x00\x70\x00\x71\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x00\x00\xc4\x00\xe7\x00\xe7\x00\xe7\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe7\x00\xe8\x00\xe8\x00\xe8\x00\x00\x00\x00\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x00\x00\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe8\x00\xe9\x00\xe9\x00\xe9\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xe9\x00\xea\x00\xea\x00\xea\x00\x00\x00\x00\x00\x00\x00\xea\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x00\x00\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xea\x00\xeb\x00\xeb\x00\xeb\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xec\x00\xec\x00\xec\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xed\x00\xed\x00\xed\x00\x00\x00\x00\x00\x00\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\x00\x00\x00\x00\x00\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x00\x00\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\xf3\x00\xee\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xf3\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf4\x00\x00\x00\x00\x00\xf3\x00\xf3\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\xf4\x00\xf4\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\xf4\x00\xf3\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\x00\x00\xf3\x00\xf4\x00\x00\x00\xf4\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\xf9\x00\xf4\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xa0\x00\xf9\x00\xf9\x00\x06\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\xd6\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xbe\x00\xf9\x00\xf9\x00\xcb\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xcc\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xd8\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\xda\x00\xf9\x00\xf9\x00\x00\x00\xf6\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd7\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xd7\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xce\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\xd0\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xce\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xcd\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xfc\x00\xf9\x00\xf9\x00\x00\x00\xcf\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xcd\x00\xff\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\xf9\x00\xff\x00\xf9\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\xc3\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#+ "\x00\x00\x98\x00\xf3\x00\xf1\x00\xa1\x00\xff\x00\x92\x00\xd9\x00\xa2\x00\xab\x00\x94\x00\xb4\x00\x92\x00\x92\x00\x92\x00\xb1\x00\xc1\x00\xc2\x00\xc4\x00\x82\x00\x17\x00\x18\x00\x1a\x00\x56\x00\x20\x00\x4f\x00\x2c\x00\x33\x00\x14\x00\x13\x00\x35\x00\x12\x00\x98\x00\x92\x00\xff\x00\x27\x01\x00\x01\x03\x01\xff\x00\xff\x00\x26\x01\xe2\x00\xe3\x00\xff\x00\xff\x00\xe7\x00\xfb\x00\xff\x00\xff\x00\x07\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x04\x01\xe8\x00\xff\x00\xff\x00\xff\x00\x01\x01\xda\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xe5\x00\xff\x00\xe6\x00\xff\x00\xf1\x00\xe9\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xeb\x00\xfd\x00\xec\x00\xff\x00\x92\x00\x0d\x01\x0d\x01\x2e\x00\x94\x00\xaa\x00\x92\x00\x92\x00\x92\x00\x92\x00\x08\x01\x08\x01\xcb\x00\x94\x00\xa2\x00\x92\x00\x92\x00\x92\x00\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\xcd\x00\x92\x00\xc7\x00\x96\x00\xac\x00\x97\x00\x81\x00\xdf\x00\xc7\x00\xf5\x00\x92\x00\x92\x00\xf6\x00\x00\x00\x11\x00\x94\x00\xb0\x00\x92\x00\x92\x00\x92\x00\xf7\x00\xf8\x00\x20\x01\x11\x00\x21\x01\x22\x01\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x19\x01\x23\x01\x92\x00\x92\x00\x25\x01\xb2\x00\x00\x00\x94\x00\xb0\x00\x92\x00\x92\x00\x92\x00\x92\x00\x08\x01\x08\x01\x11\x00\x94\x00\xb0\x00\x92\x00\x92\x00\x92\x00\x92\x00\x1d\x01\x00\x00\xc7\x00\x94\x00\x00\x00\x92\x00\x92\x00\x92\x00\x92\x00\x00\x00\xc1\x00\xb2\x00\x00\x00\x0d\x01\x0d\x01\x00\x00\x00\x00\x92\x00\x00\x00\x00\x00\xb2\x00\x11\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x92\x00\x36\x00\x00\x00\x92\x00\x11\x00\x00\x00\xc7\x00\x94\x00\x0e\x00\x92\x00\x92\x00\x92\x00\xdb\x00\x11\x00\x63\x00\x00\x00\x63\x00\x0e\x00\x00\x00\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x92\x00\x92\x00\x00\x00\x00\x00\x94\x00\x93\x00\x92\x00\x92\x00\x92\x00\x95\x00\xff\xff\x93\x00\x93\x00\x93\x00\x11\x00\x00\x00\xaf\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x92\x00\x30\x00\x80\x00\x00\x00\x00\x00\x93\x00\x30\x00\x30\x00\x30\x00\x30\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xb3\x00\x30\x00\x00\x00\x00\x00\x23\x00\x30\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x30\x00\x30\x00\x30\x00\x30\x00\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x30\x00\x92\x00\x00\x00\x23\x00\x00\x00\x00\x00\x0e\x00\x92\x00\x92\x00\x92\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x00\x00\x00\x00\x92\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x92\x00\x92\x00\x92\x00\x66\x00\x00\x00\x66\x00\x00\x00\x00\x00\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x00\x00\x00\x00\x92\x00\x92\x00\x00\x00\x00\x00\x94\x00\x92\x00\x92\x00\x92\x00\x92\x00\x94\x00\x00\x00\x92\x00\x92\x00\x92\x00\x11\x00\x00\x00\x00\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\x92\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x92\x00\x7b\x00\x00\x00\x22\x00\xc5\x00\xc7\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x0f\x00\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\xf2\x00\x00\x00\x00\x00\x92\x00\x00\x00\x00\x00\x00\x00\x94\x00\xb4\x00\x92\x00\x92\x00\x92\x00\x68\x00\x00\x00\x68\x00\x00\x00\x00\x00\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x00\x00\x00\x00\x0e\x00\x92\x00\x00\x00\xc7\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\xe3\x00\x00\x00\x00\x00\xe7\x00\x10\x00\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x00\x00\x0e\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x0e\x00\x00\x00\xc7\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xe4\x00\x00\x00\xe6\x00\x00\x00\xf2\x00\xe9\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xea\x00\x00\x00\xec\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x6b\x00\x00\x00\x14\x00\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x16\x00\x16\x00\x16\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x7b\x00\x00\x00\x00\x00\xc6\x00\xc7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x00\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\xc7\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xc3\x00\xc3\x00\xc3\x00\xc7\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x19\x00\x19\x00\x19\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\x00\x00\x18\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\x6a\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\x8f\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x8c\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x1d\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x1e\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x53\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x50\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x2b\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x2d\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x75\x00\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x1a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x09\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x15\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\xee\x00\x00\x00\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x1e\x01\x00\x00\x00\x00\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xef\x00\xed\x00\x00\x00\xf9\x00\xee\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xed\x00\x00\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\x1c\x01\xf9\x00\x00\x00\xf9\x00\x75\x00\x75\x00\x75\x00\x00\x00\x00\x00\x00\x00\x75\x00\x69\x00\x00\x00\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x17\x01\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x24\x01\xd8\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x24\x01\x00\x00\x00\x00\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\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\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\xd7\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\xd0\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\xcf\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\xce\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\xcc\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x7c\x00\xc0\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x80\x00\x80\x00\x80\x00\x00\x00\x80\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x80\x00\xba\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x52\x00\x51\x00\x2d\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x3f\x00\x34\x00\x37\x00\x37\x00\x37\x00\x38\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x54\x00\x2b\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x40\x00\x41\x00\x32\x00\x39\x00\x39\x00\x39\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\xff\xff\x93\x00\x93\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x6a\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\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\x18\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\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\x1b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x00\x00\x00\x00\x1f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x00\x00\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0a\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x00\x00\x00\x00\x00\x00\x65\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x0f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\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\x1c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x90\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\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\x24\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\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x14\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8d\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\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\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8a\x00\x1d\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5c\x00\x27\x00\x46\x00\x46\x00\x46\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x88\x00\x87\x00\x1e\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x59\x00\x5a\x00\x28\x00\x44\x00\x44\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8a\x00\x1d\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5c\x00\x27\x00\x46\x00\x46\x00\x46\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x84\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\xa0\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x84\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\xa0\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8d\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\xa0\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8d\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\xbe\x00\xbe\x00\x00\x00\xa3\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\xbe\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x84\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xbe\x00\x00\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\xbe\x00\xbe\x00\x00\x00\xa3\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\xbe\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8d\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xa5\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x85\x00\x84\x00\x1f\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x58\x00\x29\x00\x42\x00\x42\x00\x42\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xa5\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8d\x00\x1c\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5d\x00\x5e\x00\x26\x00\x48\x00\x48\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x90\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x90\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x91\x00\x90\x00\x1b\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x5f\x00\x60\x00\x25\x00\x4a\x00\x4a\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xb6\x00\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x19\x00\x19\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\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\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x19\x00\x19\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\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\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x80\x00\x80\x00\x80\x00\x80\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x80\x00\xba\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbd\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x14\x00\xbd\x00\xbd\x00\xbd\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbd\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xb6\x00\xbe\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7f\x00\x7e\x00\x21\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4d\x00\x4e\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x7c\x00\xc0\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\x7c\x00\xc3\x00\xc3\x00\xc3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x16\x00\x16\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\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\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xb8\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd4\x00\xd4\x00\xd4\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\x00\x00\x00\x00\x00\x00\xff\x00\xd4\x00\x00\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\x00\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x3b\x00\x76\x00\x00\x00\x00\x00\xde\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x76\x00\x76\x00\x76\x00\x78\x00\x7a\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x79\x00\x76\x00\x76\x00\x76\x00\x77\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x76\x00\x00\x00\xca\x00\xed\x00\xed\x00\xed\x00\x00\x00\x00\x00\x00\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x00\x00\x00\x00\x00\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x00\x00\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xed\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xef\x00\xef\x00\xef\x00\x00\x00\x00\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\x00\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xf0\x00\xf0\x00\xf0\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf0\x00\xf1\x00\xf1\x00\xf1\x00\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x00\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf2\x00\xf2\x00\xf2\x00\x00\x00\x00\x00\x00\x00\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\x00\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf3\x00\xf3\x00\xf3\x00\x00\x00\x00\x00\x00\x00\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\x00\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf3\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xf4\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xfa\x00\x00\x00\x00\x00\xf9\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\xf9\x00\x00\x00\x00\x00\x00\x00\xfa\x00\x00\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\x00\x00\x00\x00\x00\x00\xfa\x00\xfa\x00\x00\x00\xfa\x00\xfa\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xfa\x00\xf9\x00\xfa\x00\xfa\x00\xfa\x00\xfa\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\xf9\x00\x00\x00\xf9\x00\xfa\x00\x00\x00\xfa\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\xff\x00\xfa\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xa6\x00\xff\x00\xff\x00\x0c\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\xdc\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\xff\x00\xc4\x00\xff\x00\xff\x00\xd1\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\xd2\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xde\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\xe0\x00\xff\x00\xff\x00\x00\x00\xfc\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xde\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xdd\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xdd\x00\x00\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xd4\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\xd6\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xd4\x00\x00\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd4\x00\xd3\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\x02\x01\xff\x00\xff\x00\x00\x00\xd5\x00\x00\x00\xff\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\xff\x00\xd3\x00\x05\x01\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\xff\x00\x05\x01\xff\x00\x05\x01\x05\x01\x05\x01\x05\x01\x00\x00\x00\x00\x05\x01\x05\x01\x05\x01\x00\x00\x05\x01\x05\x01\x05\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x05\x01\x05\x01\x05\x01\x05\x01\x00\x00\x00\x00\x00\x00\x05\x01\x05\x01\x00\x00\x05\x01\x05\x01\x05\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\xc9\x00\x05\x01\x05\x01\x00\x00\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x05\x01\x00\x00\x00\x00\x05\x01\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# alex_check :: AlexAddr alex_check = AlexA#- "\xff\xff\x2d\x00\x01\x00\x02\x00\x2d\x00\x04\x00\x05\x00\x06\x00\x2d\x00\x65\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x65\x00\x7d\x00\x7d\x00\x7d\x00\x61\x00\x2d\x00\x2d\x00\x2d\x00\x69\x00\x6d\x00\x69\x00\x67\x00\x61\x00\x23\x00\x6e\x00\x72\x00\x6e\x00\x2d\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x05\x00\x30\x00\x31\x00\x6c\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x30\x00\x31\x00\x7c\x00\x09\x00\x2d\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x7c\x00\x20\x00\x24\x00\x2d\x00\x23\x00\x2d\x00\x21\x00\x23\x00\x2a\x00\x23\x00\x20\x00\x05\x00\x23\x00\xff\xff\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x23\x00\x23\x00\x23\x00\x2d\x00\x23\x00\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x23\x00\x23\x00\x20\x00\x05\x00\x23\x00\x23\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x30\x00\x31\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x23\x00\xff\xff\x5e\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x7d\x00\x23\x00\xff\xff\x30\x00\x31\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x2d\x00\xff\xff\x6c\x00\xff\xff\xff\xff\x20\x00\x70\x00\xff\xff\x05\x00\x2d\x00\xff\xff\x7c\x00\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\x7c\x00\x2d\x00\x2b\x00\xff\xff\x2d\x00\x7b\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x05\x00\x20\x00\xff\xff\xff\xff\x09\x00\x05\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\xff\xff\x7b\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\x05\x00\x22\x00\xff\xff\xff\xff\x20\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x7c\x00\x20\x00\xff\xff\xff\xff\x23\x00\x05\x00\xff\xff\xff\xff\x7b\x00\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x20\x00\x05\x00\xff\xff\x23\x00\xff\xff\xff\xff\x7b\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x20\x00\xff\xff\xff\xff\x09\x00\x05\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x7b\x00\xff\xff\x3b\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\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\xff\xff\x7d\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x7c\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x7c\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x23\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\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\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\x65\x00\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x23\x00\x7c\x00\xff\xff\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x05\x00\x01\x00\x02\x00\x03\x00\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\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\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x23\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\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x7c\x00\xff\xff\x7e\x00\x5c\x00\xff\xff\x5e\x00\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\x7c\x00\x7d\x00\x7e\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\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\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x02\x00\xff\xff\x04\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\x5f\x00\x04\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x04\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#+ "\xff\xff\x2d\x00\x01\x00\x02\x00\x2d\x00\x04\x00\x05\x00\x06\x00\x2d\x00\x65\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x65\x00\x7d\x00\x7d\x00\x7d\x00\x61\x00\x2d\x00\x2d\x00\x2d\x00\x69\x00\x6d\x00\x69\x00\x67\x00\x61\x00\x23\x00\x6e\x00\x72\x00\x6e\x00\x2d\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x05\x00\x30\x00\x31\x00\x6c\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x30\x00\x31\x00\x7c\x00\x09\x00\x2d\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x7c\x00\x20\x00\x24\x00\x2d\x00\x23\x00\x2d\x00\x21\x00\x23\x00\x2a\x00\x23\x00\x20\x00\x05\x00\x23\x00\xff\xff\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x23\x00\x23\x00\x23\x00\x2d\x00\x23\x00\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x23\x00\x23\x00\x20\x00\x05\x00\x23\x00\x23\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x30\x00\x31\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x23\x00\xff\xff\x5e\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x7d\x00\x23\x00\xff\xff\x30\x00\x31\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x2d\x00\xff\xff\x6c\x00\xff\xff\xff\xff\x20\x00\x70\x00\xff\xff\x05\x00\x2d\x00\xff\xff\x7c\x00\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\x7c\x00\x2d\x00\x2b\x00\xff\xff\x2d\x00\x7b\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x05\x00\x20\x00\xff\xff\xff\xff\x09\x00\x05\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\xff\xff\x7b\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\x05\x00\x22\x00\xff\xff\xff\xff\x20\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x7c\x00\x20\x00\xff\xff\xff\xff\x23\x00\x05\x00\xff\xff\xff\xff\x7b\x00\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x20\x00\x05\x00\xff\xff\x23\x00\xff\xff\xff\xff\x7b\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x05\x00\x20\x00\xff\xff\xff\xff\x09\x00\x05\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\x20\x00\x20\x00\xff\xff\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x2a\x00\xff\xff\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7b\x00\x20\x00\xff\xff\x5e\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x7b\x00\xff\xff\x3b\x00\xff\xff\xff\xff\x7b\x00\xff\xff\x7c\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\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\xff\xff\x7d\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x7c\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x23\x00\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x23\x00\x7c\x00\xff\xff\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x23\x00\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\x23\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x05\x00\x01\x00\x02\x00\x03\x00\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\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\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\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\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x23\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\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\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\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\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\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\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\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x7c\x00\xff\xff\x7e\x00\x5c\x00\xff\xff\x5e\x00\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\x7c\x00\x7d\x00\x7e\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\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\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x02\x00\xff\xff\x04\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x5c\x00\xff\xff\x5e\x00\x5f\x00\x04\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x04\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\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\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# alex_deflt :: AlexAddr alex_deflt = AlexA#- "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\x00\x3e\x00\x40\x00\x40\x00\xff\xff\x4d\x00\x4d\x00\x52\x00\x52\x00\x55\x00\x55\x00\x57\x00\x57\x00\x59\x00\x59\x00\x5b\x00\x5b\x00\x5d\x00\x5d\x00\x5f\x00\x5f\x00\xff\xff\x79\x00\x79\x00\xff\xff\x7b\x00\x7b\x00\x7b\x00\x7c\x00\x7c\x00\x7c\x00\xff\xff\x7f\x00\x7f\x00\x82\x00\x82\x00\x85\x00\x85\x00\x88\x00\x88\x00\x8b\x00\x8b\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\xb8\x00\xb8\x00\xb8\x00\xff\xff\x7b\x00\x7c\x00\x99\x00\x99\x00\x99\x00\x97\x00\x97\x00\x97\x00\x96\x00\x96\x00\x96\x00\x95\x00\x95\x00\x95\x00\x94\x00\x94\x00\x94\x00\xff\xff\xb8\x00\xff\xff\xb8\x00\xff\xff\xff\xff\xff\xff\xb8\x00\x94\x00\x95\x00\x96\x00\x97\x00\x96\x00\x99\x00\x99\x00\x95\x00\x95\x00\x99\x00\x95\x00\x99\x00\x95\x00\x94\x00\x94\x00\x94\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\xb8\x00\xb8\x00\xff\xff\xb8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#+ "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\x00\x3e\x00\x40\x00\x40\x00\xff\xff\x4d\x00\x4d\x00\x52\x00\x52\x00\x55\x00\x55\x00\x57\x00\x57\x00\x59\x00\x59\x00\x5b\x00\x5b\x00\x5d\x00\x5d\x00\x5f\x00\x5f\x00\xff\xff\x7f\x00\x7f\x00\xff\xff\x81\x00\x81\x00\x81\x00\x82\x00\x82\x00\x82\x00\xff\xff\x85\x00\x85\x00\x88\x00\x88\x00\x8b\x00\x8b\x00\x8e\x00\x8e\x00\x91\x00\x91\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\xbe\x00\xbe\x00\xbe\x00\xff\xff\x81\x00\x82\x00\x9f\x00\x9f\x00\x9f\x00\x9d\x00\x9d\x00\x9d\x00\x9c\x00\x9c\x00\x9c\x00\x9b\x00\x9b\x00\x9b\x00\x9a\x00\x9a\x00\x9a\x00\xff\xff\xbe\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xbe\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9c\x00\x9f\x00\x9f\x00\x9b\x00\x9b\x00\x9f\x00\x9b\x00\x9f\x00\x9b\x00\x9a\x00\x9a\x00\x9a\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\xbe\x00\xbe\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# -alex_accept = listArray (0 :: Int, 285)+alex_accept = listArray (0 :: Int, 295) [ AlexAccNone+ , AlexAcc 172+ , AlexAccNone+ , AlexAcc 171+ , AlexAcc 170+ , AlexAcc 169 , AlexAcc 168 , AlexAccNone+ , AlexAccNone , AlexAcc 167- , AlexAcc 166- , AlexAcc 165- , AlexAcc 164 , AlexAccNone , AlexAccNone- , AlexAcc 163 , AlexAccNone , AlexAccNone , AlexAccNone@@ -258,89 +261,97 @@ , AlexAccNone , AlexAccNone , AlexAccNone+ , AlexAccNone+ , AlexAccNone+ , AlexAccNone+ , AlexAccNone , AlexAccSkip , AlexAccSkip- , AlexAcc 162- , AlexAcc 161- , AlexAccPred 160 ( isNormalComment )(AlexAccNone)- , AlexAccPred 159 ( isNormalComment )(AlexAccNone)- , AlexAccPred 158 ( isNormalComment )(AlexAccNone)- , AlexAccPred 157 ( isNormalComment )(AlexAcc 156)- , AlexAcc 155- , AlexAcc 154- , AlexAccPred 153 ( ifExtension (not . haddockEnabled) )(AlexAccNone)- , AlexAccPred 152 ( ifExtension (not . haddockEnabled) )(AlexAcc 151)- , AlexAccPred 150 ( ifExtension (not . haddockEnabled) )(AlexAccPred 149 ( ifExtension haddockEnabled )(AlexAccNone))- , AlexAcc 148- , AlexAccPred 147 ( atEOL )(AlexAccNone)- , AlexAccPred 146 ( atEOL )(AlexAccNone)- , AlexAccPred 145 ( atEOL )(AlexAccNone)+ , AlexAcc 166+ , AlexAcc 165+ , AlexAccPred 164 ( isNormalComment )(AlexAccNone)+ , AlexAccPred 163 ( isNormalComment )(AlexAccNone)+ , AlexAccPred 162 ( isNormalComment )(AlexAccNone)+ , AlexAccPred 161 ( isNormalComment )(AlexAcc 160)+ , AlexAcc 159+ , AlexAcc 158+ , AlexAccPred 157 ( ifExtension (not . haddockEnabled) )(AlexAccNone)+ , AlexAccPred 156 ( ifExtension (not . haddockEnabled) )(AlexAcc 155)+ , AlexAccPred 154 ( ifExtension (not . haddockEnabled) )(AlexAccPred 153 ( ifExtension haddockEnabled )(AlexAccNone))+ , AlexAcc 152+ , AlexAccPred 151 ( atEOL )(AlexAccNone)+ , AlexAccPred 150 ( atEOL )(AlexAccNone)+ , AlexAccPred 149 ( atEOL )(AlexAccNone)+ , AlexAccPred 148 ( atEOL )(AlexAcc 147)+ , AlexAccPred 146 ( atEOL )(AlexAcc 145) , AlexAccPred 144 ( atEOL )(AlexAcc 143) , AlexAccPred 142 ( atEOL )(AlexAcc 141)- , AlexAccPred 140 ( atEOL )(AlexAcc 139)+ , AlexAccPred 140 ( atEOL )(AlexAccNone)+ , AlexAccPred 139 ( atEOL )(AlexAccNone) , AlexAccPred 138 ( atEOL )(AlexAcc 137)- , AlexAccPred 136 ( atEOL )(AlexAccNone)- , AlexAccPred 135 ( atEOL )(AlexAccNone)- , AlexAccPred 134 ( atEOL )(AlexAcc 133) , AlexAccSkip- , AlexAccPred 132 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccPred 131 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False) `alexAndPred` followedByDigit )(AlexAccNone)+ , AlexAccPred 136 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+ , AlexAccPred 135 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False) `alexAndPred` followedByDigit )(AlexAccNone) , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone) , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccPred 130 ( notFollowedBy '-' )(AlexAccNone)+ , AlexAccPred 134 ( notFollowedBy '-' )(AlexAccNone) , AlexAccSkip- , AlexAccPred 129 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccPred 128 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccPred 127 ( notFollowedBySymbol )(AlexAccNone)- , AlexAcc 126- , AlexAccPred 125 ( known_pragma linePrags )(AlexAccNone)- , AlexAccPred 124 ( known_pragma linePrags )(AlexAcc 123)+ , AlexAccPred 133 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+ , AlexAccPred 132 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+ , AlexAccPred 131 ( notFollowedBySymbol )(AlexAccNone)+ , AlexAcc 130+ , AlexAccPred 129 ( known_pragma linePrags )(AlexAccNone)+ , AlexAccPred 128 ( known_pragma linePrags )(AlexAcc 127)+ , AlexAccPred 126 ( known_pragma linePrags )(AlexAccPred 125 ( known_pragma oneWordPrags )(AlexAccPred 124 ( known_pragma ignoredPrags )(AlexAccPred 123 ( known_pragma fileHeaderPrags )(AlexAccNone)))) , AlexAccPred 122 ( known_pragma linePrags )(AlexAccPred 121 ( known_pragma oneWordPrags )(AlexAccPred 120 ( known_pragma ignoredPrags )(AlexAccPred 119 ( known_pragma fileHeaderPrags )(AlexAccNone))))- , AlexAccPred 118 ( known_pragma linePrags )(AlexAccPred 117 ( known_pragma oneWordPrags )(AlexAccPred 116 ( known_pragma ignoredPrags )(AlexAccPred 115 ( known_pragma fileHeaderPrags )(AlexAccNone))))+ , AlexAcc 118+ , AlexAcc 117+ , AlexAcc 116+ , AlexAcc 115 , AlexAcc 114 , AlexAcc 113 , AlexAcc 112 , AlexAcc 111 , AlexAcc 110 , AlexAcc 109- , AlexAcc 108+ , AlexAccPred 108 ( known_pragma twoWordPrags )(AlexAccNone) , AlexAcc 107 , AlexAcc 106 , AlexAcc 105- , AlexAccPred 104 ( known_pragma twoWordPrags )(AlexAccNone)- , AlexAcc 103- , AlexAcc 102- , AlexAcc 101- , AlexAccPred 100 ( ifExtension haddockEnabled )(AlexAccNone)- , AlexAccPred 99 ( ifExtension parrEnabled )(AlexAccNone)- , AlexAccPred 98 ( ifExtension parrEnabled )(AlexAccNone)+ , AlexAccPred 104 ( ifExtension haddockEnabled )(AlexAccNone)+ , AlexAccPred 103 ( ifExtension parrEnabled )(AlexAccNone)+ , AlexAccPred 102 ( ifExtension parrEnabled )(AlexAccNone)+ , AlexAccPred 101 ( ifExtension thQuotesEnabled )(AlexAccNone)+ , AlexAccPred 100 ( ifExtension thQuotesEnabled )(AlexAccNone)+ , AlexAccPred 99 ( ifExtension thQuotesEnabled )(AlexAccPred 98 ( ifExtension qqEnabled )(AlexAccNone)) , AlexAccPred 97 ( ifExtension thQuotesEnabled )(AlexAccNone)- , AlexAccPred 96 ( ifExtension thQuotesEnabled )(AlexAccNone)- , AlexAccPred 95 ( ifExtension thQuotesEnabled )(AlexAccPred 94 ( ifExtension qqEnabled )(AlexAccNone))- , AlexAccPred 93 ( ifExtension thQuotesEnabled )(AlexAccNone)+ , AlexAccPred 96 ( ifExtension thQuotesEnabled )(AlexAccPred 95 ( ifExtension qqEnabled )(AlexAccNone))+ , AlexAccPred 94 ( ifExtension thQuotesEnabled )(AlexAccPred 93 ( ifExtension qqEnabled )(AlexAccNone)) , AlexAccPred 92 ( ifExtension thQuotesEnabled )(AlexAccPred 91 ( ifExtension qqEnabled )(AlexAccNone))- , AlexAccPred 90 ( ifExtension thQuotesEnabled )(AlexAccPred 89 ( ifExtension qqEnabled )(AlexAccNone))- , AlexAccPred 88 ( ifExtension thQuotesEnabled )(AlexAccPred 87 ( ifExtension qqEnabled )(AlexAccNone))- , AlexAccPred 86 ( ifExtension thQuotesEnabled )(AlexAccNone)- , AlexAccPred 85 ( ifExtension thQuotesEnabled )(AlexAccNone)- , AlexAccPred 84 ( ifExtension thEnabled )(AlexAccNone)- , AlexAccPred 83 ( ifExtension thEnabled )(AlexAccNone)- , AlexAccPred 82 ( ifExtension thEnabled )(AlexAccNone)- , AlexAccPred 81 ( ifExtension thEnabled )(AlexAccNone)- , AlexAccPred 80 ( ifExtension qqEnabled )(AlexAccNone)- , AlexAccPred 79 ( ifExtension qqEnabled )(AlexAccNone)- , AlexAccPred 78 ( ifCurrentChar '⟦' `alexAndPred`- ifExtension (\i -> unicodeSyntaxEnabled i && thQuotesEnabled i) )(AlexAccPred 77 ( ifCurrentChar '⟧' `alexAndPred`- ifExtension (\i -> unicodeSyntaxEnabled i && thQuotesEnabled i) )(AlexAccPred 76 ( ifCurrentChar '⦇' `alexAndPred`- ifExtension (\i -> unicodeSyntaxEnabled i && arrowsEnabled i) )(AlexAccPred 75 ( ifCurrentChar '⦈' `alexAndPred`+ , AlexAccPred 90 ( ifExtension thQuotesEnabled )(AlexAccNone)+ , AlexAccPred 89 ( ifExtension thQuotesEnabled )(AlexAccNone)+ , AlexAccPred 88 ( ifExtension thEnabled )(AlexAccNone)+ , AlexAccPred 87 ( ifExtension thEnabled )(AlexAccNone)+ , AlexAccPred 86 ( ifExtension thEnabled )(AlexAccNone)+ , AlexAccPred 85 ( ifExtension thEnabled )(AlexAccNone)+ , AlexAccPred 84 ( ifExtension qqEnabled )(AlexAccNone)+ , AlexAccPred 83 ( ifExtension qqEnabled )(AlexAccNone)+ , AlexAccPred 82 ( ifCurrentChar '⟦' `alexAndPred`+ ifExtension (\i -> unicodeSyntaxEnabled i && thQuotesEnabled i) )(AlexAccPred 81 ( ifCurrentChar '⟧' `alexAndPred`+ ifExtension (\i -> unicodeSyntaxEnabled i && thQuotesEnabled i) )(AlexAccPred 80 ( ifCurrentChar '⦇' `alexAndPred`+ ifExtension (\i -> unicodeSyntaxEnabled i && arrowsEnabled i) )(AlexAccPred 79 ( ifCurrentChar '⦈' `alexAndPred` ifExtension (\i -> unicodeSyntaxEnabled i && arrowsEnabled i) )(AlexAccNone))))- , AlexAccPred 74 (alexPrevCharMatches(\c -> True && c < '\SOH' || c > '\ETX' && c < '\a' || c > '\a' && c < '\n' || c > '\n' && c < '\'' || c > '\'' && c < ')' || c > ')' && c < '0' || c > '9' && c < 'A' || c > 'Z' && c < '_' || c > '_' && c < 'a' || c > 'z' && True || False) `alexAndPred` ifExtension typeApplicationEnabled `alexAndPred` notFollowedBySymbol )(AlexAcc 73)- , AlexAccPred 72 ( ifExtension arrowsEnabled `alexAndPred` notFollowedBySymbol )(AlexAccNone)- , AlexAccPred 71 ( ifExtension arrowsEnabled )(AlexAccNone)- , AlexAccPred 70 ( ifExtension ipEnabled )(AlexAccNone)- , AlexAccPred 69 ( ifExtension overloadedLabelsEnabled )(AlexAccNone)- , AlexAccPred 68 ( orExtensions unboxedTuplesEnabled unboxedSumsEnabled )(AlexAccNone)- , AlexAccPred 67 ( orExtensions unboxedTuplesEnabled unboxedSumsEnabled )(AlexAccNone)+ , AlexAccPred 78 (alexPrevCharMatches(\c -> True && c < '\SOH' || c > '\ETX' && c < '\a' || c > '\a' && c < '\n' || c > '\n' && c < '\'' || c > '\'' && c < ')' || c > ')' && c < '0' || c > '9' && c < 'A' || c > 'Z' && c < '_' || c > '_' && c < 'a' || c > 'z' && True || False) `alexAndPred` ifExtension typeApplicationEnabled `alexAndPred` notFollowedBySymbol )(AlexAcc 77)+ , AlexAccPred 76 ( ifExtension arrowsEnabled `alexAndPred` notFollowedBySymbol )(AlexAccNone)+ , AlexAccPred 75 ( ifExtension arrowsEnabled )(AlexAccNone)+ , AlexAccPred 74 ( ifExtension ipEnabled )(AlexAccNone)+ , AlexAccPred 73 ( ifExtension overloadedLabelsEnabled )(AlexAccNone)+ , AlexAccPred 72 ( orExtensions unboxedTuplesEnabled unboxedSumsEnabled )(AlexAccNone)+ , AlexAccPred 71 ( orExtensions unboxedTuplesEnabled unboxedSumsEnabled )(AlexAccNone)+ , AlexAcc 70+ , AlexAcc 69+ , AlexAcc 68+ , AlexAcc 67 , AlexAcc 66 , AlexAcc 65 , AlexAcc 64@@ -357,14 +368,14 @@ , AlexAcc 53 , AlexAcc 52 , AlexAcc 51- , AlexAcc 50- , AlexAcc 49- , AlexAcc 48- , AlexAcc 47- , AlexAccPred 46 ( ifExtension magicHashEnabled )(AlexAccNone)- , AlexAccPred 45 ( ifExtension magicHashEnabled )(AlexAccNone)- , AlexAccPred 44 ( ifExtension magicHashEnabled )(AlexAccNone)- , AlexAccPred 43 ( ifExtension magicHashEnabled )(AlexAccNone)+ , AlexAccPred 50 ( ifExtension magicHashEnabled )(AlexAccNone)+ , AlexAccPred 49 ( ifExtension magicHashEnabled )(AlexAccNone)+ , AlexAccPred 48 ( ifExtension magicHashEnabled )(AlexAccNone)+ , AlexAccPred 47 ( ifExtension magicHashEnabled )(AlexAccNone)+ , AlexAcc 46+ , AlexAcc 45+ , AlexAcc 44+ , AlexAcc 43 , AlexAcc 42 , AlexAcc 41 , AlexAcc 40@@ -376,23 +387,25 @@ , AlexAcc 34 , AlexAcc 33 , AlexAcc 32- , AlexAcc 31+ , AlexAccPred 31 ( ifExtension binaryLiteralsEnabled )(AlexAccNone) , AlexAcc 30 , AlexAcc 29- , AlexAcc 28- , AlexAccPred 27 ( ifExtension binaryLiteralsEnabled )(AlexAccNone)- , AlexAcc 26- , AlexAcc 25- , AlexAccPred 24 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)- , AlexAccPred 23 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)- , AlexAccPred 22 ( ifExtension negativeLiteralsEnabled `alexAndPred`+ , AlexAccPred 28 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 27 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 26 ( ifExtension negativeLiteralsEnabled `alexAndPred` ifExtension binaryLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 25 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 24 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)+ , AlexAcc 23+ , AlexAcc 22 , AlexAccPred 21 ( ifExtension negativeLiteralsEnabled )(AlexAccNone) , AlexAccPred 20 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)- , AlexAcc 19- , AlexAcc 18- , AlexAccPred 17 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)- , AlexAccPred 16 ( ifExtension negativeLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 19 ( ifExtension hexFloatLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 18 ( ifExtension hexFloatLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 17 ( ifExtension hexFloatLiteralsEnabled `alexAndPred`+ ifExtension negativeLiteralsEnabled )(AlexAccNone)+ , AlexAccPred 16 ( ifExtension hexFloatLiteralsEnabled `alexAndPred`+ ifExtension negativeLiteralsEnabled )(AlexAccNone) , AlexAccPred 15 ( ifExtension magicHashEnabled )(AlexAccNone) , AlexAccPred 14 ( ifExtension magicHashEnabled `alexAndPred` ifExtension binaryLiteralsEnabled )(AlexAccNone)@@ -414,179 +427,183 @@ , AlexAcc 0 ] -alex_actions = array (0 :: Int, 169)- [ (168,alex_action_14)- , (167,alex_action_20)- , (166,alex_action_21)- , (165,alex_action_19)- , (164,alex_action_22)- , (163,alex_action_27)- , (162,alex_action_1)- , (161,alex_action_1)- , (160,alex_action_2)- , (159,alex_action_2)- , (158,alex_action_2)- , (157,alex_action_2)- , (156,alex_action_27)- , (155,alex_action_3)- , (154,alex_action_4)- , (153,alex_action_5)- , (152,alex_action_5)- , (151,alex_action_27)- , (150,alex_action_5)- , (149,alex_action_39)- , (148,alex_action_6)- , (147,alex_action_7)+alex_actions = array (0 :: Int, 173)+ [ (172,alex_action_14)+ , (171,alex_action_20)+ , (170,alex_action_21)+ , (169,alex_action_19)+ , (168,alex_action_22)+ , (167,alex_action_27)+ , (166,alex_action_1)+ , (165,alex_action_1)+ , (164,alex_action_2)+ , (163,alex_action_2)+ , (162,alex_action_2)+ , (161,alex_action_2)+ , (160,alex_action_27)+ , (159,alex_action_3)+ , (158,alex_action_4)+ , (157,alex_action_5)+ , (156,alex_action_5)+ , (155,alex_action_27)+ , (154,alex_action_5)+ , (153,alex_action_39)+ , (152,alex_action_6)+ , (151,alex_action_7)+ , (150,alex_action_7)+ , (149,alex_action_7)+ , (148,alex_action_7)+ , (147,alex_action_27) , (146,alex_action_7)- , (145,alex_action_7)+ , (145,alex_action_27) , (144,alex_action_7)- , (143,alex_action_27)+ , (143,alex_action_88) , (142,alex_action_7)- , (141,alex_action_27)- , (140,alex_action_7)- , (139,alex_action_88)- , (138,alex_action_7)- , (137,alex_action_88)- , (136,alex_action_8)- , (135,alex_action_8)- , (134,alex_action_8)- , (133,alex_action_27)- , (132,alex_action_10)- , (131,alex_action_11)- , (130,alex_action_15)- , (129,alex_action_17)- , (128,alex_action_17)- , (127,alex_action_18)- , (126,alex_action_23)- , (125,alex_action_24)- , (124,alex_action_24)- , (123,alex_action_27)+ , (141,alex_action_88)+ , (140,alex_action_8)+ , (139,alex_action_8)+ , (138,alex_action_8)+ , (137,alex_action_27)+ , (136,alex_action_10)+ , (135,alex_action_11)+ , (134,alex_action_15)+ , (133,alex_action_17)+ , (132,alex_action_17)+ , (131,alex_action_18)+ , (130,alex_action_23)+ , (129,alex_action_24)+ , (128,alex_action_24)+ , (127,alex_action_27)+ , (126,alex_action_24)+ , (125,alex_action_33)+ , (124,alex_action_34)+ , (123,alex_action_36) , (122,alex_action_24) , (121,alex_action_33) , (120,alex_action_34)- , (119,alex_action_36)- , (118,alex_action_24)- , (117,alex_action_33)- , (116,alex_action_34)- , (115,alex_action_37)- , (114,alex_action_25)- , (113,alex_action_26)- , (112,alex_action_27)- , (111,alex_action_27)- , (110,alex_action_27)- , (109,alex_action_27)- , (108,alex_action_28)- , (107,alex_action_29)- , (106,alex_action_30)- , (105,alex_action_31)- , (104,alex_action_32)- , (103,alex_action_35)- , (102,alex_action_38)- , (101,alex_action_38)- , (100,alex_action_40)- , (99,alex_action_41)- , (98,alex_action_42)- , (97,alex_action_43)- , (96,alex_action_44)- , (95,alex_action_45)- , (94,alex_action_56)- , (93,alex_action_46)- , (92,alex_action_47)+ , (119,alex_action_37)+ , (118,alex_action_25)+ , (117,alex_action_26)+ , (116,alex_action_27)+ , (115,alex_action_27)+ , (114,alex_action_27)+ , (113,alex_action_27)+ , (112,alex_action_28)+ , (111,alex_action_29)+ , (110,alex_action_30)+ , (109,alex_action_31)+ , (108,alex_action_32)+ , (107,alex_action_35)+ , (106,alex_action_38)+ , (105,alex_action_38)+ , (104,alex_action_40)+ , (103,alex_action_41)+ , (102,alex_action_42)+ , (101,alex_action_43)+ , (100,alex_action_44)+ , (99,alex_action_45)+ , (98,alex_action_56)+ , (97,alex_action_46)+ , (96,alex_action_47)+ , (95,alex_action_56)+ , (94,alex_action_48)+ , (93,alex_action_56)+ , (92,alex_action_49) , (91,alex_action_56)- , (90,alex_action_48)- , (89,alex_action_56)- , (88,alex_action_49)- , (87,alex_action_56)- , (86,alex_action_50)- , (85,alex_action_51)- , (84,alex_action_52)- , (83,alex_action_53)- , (82,alex_action_54)- , (81,alex_action_55)- , (80,alex_action_56)- , (79,alex_action_57)- , (78,alex_action_58)- , (77,alex_action_59)- , (76,alex_action_63)- , (75,alex_action_64)- , (74,alex_action_60)- , (73,alex_action_88)- , (72,alex_action_61)- , (71,alex_action_62)- , (70,alex_action_65)- , (69,alex_action_66)- , (68,alex_action_67)- , (67,alex_action_68)- , (66,alex_action_69)- , (65,alex_action_69)- , (64,alex_action_70)- , (63,alex_action_71)- , (62,alex_action_71)- , (61,alex_action_72)- , (60,alex_action_73)- , (59,alex_action_74)- , (58,alex_action_75)- , (57,alex_action_76)- , (56,alex_action_76)- , (55,alex_action_77)- , (54,alex_action_78)- , (53,alex_action_78)- , (52,alex_action_79)- , (51,alex_action_79)- , (50,alex_action_80)- , (49,alex_action_80)- , (48,alex_action_81)- , (47,alex_action_81)- , (46,alex_action_82)- , (45,alex_action_83)- , (44,alex_action_84)- , (43,alex_action_85)- , (42,alex_action_86)- , (41,alex_action_87)+ , (90,alex_action_50)+ , (89,alex_action_51)+ , (88,alex_action_52)+ , (87,alex_action_53)+ , (86,alex_action_54)+ , (85,alex_action_55)+ , (84,alex_action_56)+ , (83,alex_action_57)+ , (82,alex_action_58)+ , (81,alex_action_59)+ , (80,alex_action_63)+ , (79,alex_action_64)+ , (78,alex_action_60)+ , (77,alex_action_88)+ , (76,alex_action_61)+ , (75,alex_action_62)+ , (74,alex_action_65)+ , (73,alex_action_66)+ , (72,alex_action_67)+ , (71,alex_action_68)+ , (70,alex_action_69)+ , (69,alex_action_69)+ , (68,alex_action_70)+ , (67,alex_action_71)+ , (66,alex_action_71)+ , (65,alex_action_72)+ , (64,alex_action_73)+ , (63,alex_action_74)+ , (62,alex_action_75)+ , (61,alex_action_76)+ , (60,alex_action_76)+ , (59,alex_action_77)+ , (58,alex_action_78)+ , (57,alex_action_78)+ , (56,alex_action_79)+ , (55,alex_action_79)+ , (54,alex_action_80)+ , (53,alex_action_80)+ , (52,alex_action_81)+ , (51,alex_action_81)+ , (50,alex_action_82)+ , (49,alex_action_83)+ , (48,alex_action_84)+ , (47,alex_action_85)+ , (46,alex_action_86)+ , (45,alex_action_87)+ , (44,alex_action_88)+ , (43,alex_action_88)+ , (42,alex_action_88)+ , (41,alex_action_88) , (40,alex_action_88) , (39,alex_action_88) , (38,alex_action_88) , (37,alex_action_88) , (36,alex_action_88)- , (35,alex_action_88)- , (34,alex_action_88)- , (33,alex_action_88)- , (32,alex_action_88)- , (31,alex_action_89)- , (30,alex_action_89)- , (29,alex_action_90)- , (28,alex_action_90)- , (27,alex_action_91)- , (26,alex_action_92)- , (25,alex_action_93)- , (24,alex_action_94)- , (23,alex_action_94)- , (22,alex_action_95)- , (21,alex_action_96)- , (20,alex_action_97)- , (19,alex_action_98)- , (18,alex_action_98)- , (17,alex_action_99)- , (16,alex_action_99)- , (15,alex_action_100)- , (14,alex_action_101)- , (13,alex_action_102)- , (12,alex_action_103)- , (11,alex_action_104)- , (10,alex_action_105)- , (9,alex_action_106)- , (8,alex_action_107)- , (7,alex_action_108)- , (6,alex_action_109)- , (5,alex_action_110)- , (4,alex_action_111)- , (3,alex_action_112)- , (2,alex_action_113)- , (1,alex_action_114)- , (0,alex_action_115)+ , (35,alex_action_89)+ , (34,alex_action_89)+ , (33,alex_action_90)+ , (32,alex_action_90)+ , (31,alex_action_91)+ , (30,alex_action_92)+ , (29,alex_action_93)+ , (28,alex_action_94)+ , (27,alex_action_94)+ , (26,alex_action_95)+ , (25,alex_action_96)+ , (24,alex_action_97)+ , (23,alex_action_98)+ , (22,alex_action_98)+ , (21,alex_action_99)+ , (20,alex_action_99)+ , (19,alex_action_100)+ , (18,alex_action_100)+ , (17,alex_action_101)+ , (16,alex_action_101)+ , (15,alex_action_102)+ , (14,alex_action_103)+ , (13,alex_action_104)+ , (12,alex_action_105)+ , (11,alex_action_106)+ , (10,alex_action_107)+ , (9,alex_action_108)+ , (8,alex_action_109)+ , (7,alex_action_110)+ , (6,alex_action_111)+ , (5,alex_action_112)+ , (4,alex_action_113)+ , (3,alex_action_114)+ , (2,alex_action_115)+ , (1,alex_action_116)+ , (0,alex_action_117) ] -{-# LINE 568 "parser/Lexer.x" #-}+{-# LINE 574 "parser/Lexer.x" #-} -- -----------------------------------------------------------------------------@@ -656,7 +673,8 @@ | ITrules_prag SourceText | ITwarning_prag SourceText | ITdeprecated_prag SourceText- | ITline_prag+ | ITline_prag SourceText -- not usually produced, see 'use_pos_prags'+ | ITcolumn_prag SourceText -- not usually produced, see 'use_pos_prags' | ITscc_prag SourceText | ITgenerated_prag SourceText | ITcore_prag SourceText -- hdaume: core annotations@@ -729,7 +747,7 @@ | ITchar SourceText Char -- Note [Literal source text] in BasicTypes | ITstring SourceText FastString -- Note [Literal source text] in BasicTypes- | ITinteger SourceText Integer -- Note [Literal source text] in BasicTypes+ | ITinteger IntegralLit -- Note [Literal source text] in BasicTypes | ITrational FractionalLit | ITprimchar SourceText Char -- Note [Literal source text] in BasicTypes@@ -1156,6 +1174,27 @@ let !src = lexemeToString buf len return (L span (ITrules_prag (SourceText src))) +-- When 'use_pos_prags' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+linePrag :: Action+linePrag span buf len = do+ ps <- getPState+ if use_pos_prags ps+ then begin line_prag2 span buf len+ else let !src = lexemeToString buf len+ in return (L span (ITline_prag (SourceText src)))++-- When 'use_pos_prags' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+columnPrag :: Action+columnPrag span buf len = do+ ps <- getPState+ let !src = lexemeToString buf len+ if use_pos_prags ps+ then begin column_prag span buf len+ else let !src = lexemeToString buf len+ in return (L span (ITcolumn_prag (SourceText src)))+ endPrag :: Action endPrag span _buf _len = do setExts (.&. complement (xbit InRulePragBit))@@ -1298,15 +1337,21 @@ $! transint $ parseUnsignedInteger (offsetBytes transbuf buf) (subtract translen len) radix char_to_int --- some conveniences for use with tok_integral tok_num :: (Integer -> Integer)- -> Int -> Int- -> (Integer, (Char->Int)) -> Action-tok_num = tok_integral ITinteger+ -> Int -> Int+ -> (Integer, (Char->Int)) -> Action+tok_num = tok_integral itint+ where+ itint st@(SourceText ('-':str)) val = ITinteger (((IL $! st) $! True) $! val)+ itint st@(SourceText str ) val = ITinteger (((IL $! st) $! False) $! val)+ itint st@(NoSourceText ) val = ITinteger (((IL $! st) $! (val < 0)) $! val)+ tok_primint :: (Integer -> Integer) -> Int -> Int -> (Integer, (Char->Int)) -> Action tok_primint = tok_integral ITprimint++ tok_primword :: Int -> Int -> (Integer, (Char->Int)) -> Action tok_primword = tok_integral ITprimword positive@@ -1322,11 +1367,22 @@ -- readRational can understand negative rationals, exponents, everything. tok_float, tok_primfloat, tok_primdouble :: String -> Token tok_float str = ITrational $! readFractionalLit str+tok_hex_float str = ITrational $! readHexFractionalLit str tok_primfloat str = ITprimfloat $! readFractionalLit str tok_primdouble str = ITprimdouble $! readFractionalLit str readFractionalLit :: String -> FractionalLit-readFractionalLit str = (FL $! str) $! readRational str+readFractionalLit str = ((FL $! (SourceText str)) $! is_neg) $! readRational str+ where is_neg = case str of ('-':_) -> True+ _ -> False+readHexFractionalLit :: String -> FractionalLit+readHexFractionalLit str =+ FL { fl_text = SourceText str+ , fl_neg = case str of+ '-' : _ -> True+ _ -> False+ , fl_value = readHexRational str+ } -- ----------------------------------------------------------------------------- -- Layout processing@@ -1813,23 +1869,27 @@ data ParseResult a = POk PState a | PFailed- SrcSpan -- The start and end of the text span related to- -- the error. Might be used in environments which can- -- show this span, e.g. by highlighting it.- MsgDoc -- The error message+ (DynFlags -> Messages) -- A function that returns warnings that+ -- accumulated during parsing, including+ -- the warnings related to tabs.+ SrcSpan -- The start and end of the text span related+ -- to the error. Might be used in environments+ -- which can show this span, e.g. by+ -- highlighting it.+ MsgDoc -- The error message -- | Test whether a 'WarningFlag' is set warnopt :: WarningFlag -> ParserFlags -> Bool-warnopt f options = fromEnum f `IntSet.member` pWarningFlags options+warnopt f options = f `EnumSet.member` pWarningFlags options -- | Test whether a 'LangExt.Extension' is set extopt :: LangExt.Extension -> ParserFlags -> Bool-extopt f options = fromEnum f `IntSet.member` pExtensionFlags options+extopt f options = f `EnumSet.member` pExtensionFlags options -- | The subset of the 'DynFlags' used by the parser data ParserFlags = ParserFlags {- pWarningFlags :: IntSet- , pExtensionFlags :: IntSet+ pWarningFlags :: EnumSet WarningFlag+ , pExtensionFlags :: EnumSet LangExt.Extension , pThisPackage :: UnitId -- ^ key of package currently being compiled , pExtsBitmap :: !ExtsBitmap -- ^ bitmap of permitted extensions }@@ -1868,6 +1928,10 @@ -- token doesn't need to close anything: alr_justClosedExplicitLetBlock :: Bool, + -- If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}'+ -- update the 'loc' field. Otherwise, those pragmas are lexed as tokens.+ use_pos_prags :: Bool,+ -- The next three are used to implement Annotations giving the -- locations of 'noise' tokens in the source, so that users of -- the GHC API can do source to source conversions.@@ -1901,12 +1965,10 @@ instance Monad P where (>>=) = thenP- fail = failP+ fail = MonadFail.fail -#if __GLASGOW_HASKELL__ > 710 instance MonadFail P where fail = failP-#endif returnP :: a -> P a returnP a = a `seq` (P $ \s -> POk s a)@@ -1915,19 +1977,27 @@ (P m) `thenP` k = P $ \ s -> case m s of POk s1 a -> (unP (k a)) s1- PFailed span err -> PFailed span err+ PFailed warnFn span err -> PFailed warnFn span err failP :: String -> P a-failP msg = P $ \s -> PFailed (RealSrcSpan (last_loc s)) (text msg)+failP msg =+ P $ \s ->+ PFailed (getMessages s) (RealSrcSpan (last_loc s)) (text msg) failMsgP :: String -> P a-failMsgP msg = P $ \s -> PFailed (RealSrcSpan (last_loc s)) (text msg)+failMsgP msg =+ P $ \s ->+ PFailed (getMessages s) (RealSrcSpan (last_loc s)) (text msg) failLocMsgP :: RealSrcLoc -> RealSrcLoc -> String -> P a-failLocMsgP loc1 loc2 str = P $ \_ -> PFailed (RealSrcSpan (mkRealSrcSpan loc1 loc2)) (text str)+failLocMsgP loc1 loc2 str =+ P $ \s ->+ PFailed (getMessages s) (RealSrcSpan (mkRealSrcSpan loc1 loc2)) (text str) failSpanMsgP :: SrcSpan -> SDoc -> P a-failSpanMsgP span msg = P $ \_ -> PFailed span msg+failSpanMsgP span msg =+ P $ \s ->+ PFailed (getMessages s) span msg getPState :: P PState getPState = P $ \s -> POk s s@@ -1971,27 +2041,29 @@ data AlexInput = AI RealSrcLoc StringBuffer -alexInputPrevChar :: AlexInput -> Char-alexInputPrevChar (AI _ buf) = prevChar buf '\n'+{-+Note [Unicode in Alex]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Although newer versions of Alex support unicode, this grammar is processed with+the old style '--latin1' behaviour. This means that when implementing the+functions --- backwards compatibility for Alex 2.x-alexGetChar :: AlexInput -> Maybe (Char,AlexInput)-alexGetChar inp = case alexGetByte inp of- Nothing -> Nothing- Just (b,i) -> c `seq` Just (c,i)- where c = chr $ fromIntegral b+ alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)+ alexInputPrevChar :: AlexInput -> Char -alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)-alexGetByte (AI loc s)- | atEnd s = Nothing- | otherwise = byte `seq` loc' `seq` s' `seq`- --trace (show (ord c)) $- Just (byte, (AI loc' s'))- where (c,s') = nextChar s- loc' = advanceSrcLoc loc c- byte = fromIntegral $ ord adj_c+which Alex uses to to take apart our 'AlexInput', we must - non_graphic = '\x00'+ * return a latin1 character in the 'Word8' that 'alexGetByte' expects+ * return a latin1 character in 'alexInputPrevChar'.++We handle this in 'adjustChar' by squishing entire classes of unicode+characters into single bytes.+-}++{-# INLINE adjustChar #-}+adjustChar :: Char -> Word8+adjustChar c = fromIntegral $ ord adj_c+ where non_graphic = '\x00' upper = '\x01' lower = '\x02' digit = '\x03'@@ -2037,6 +2109,32 @@ Space -> space _other -> non_graphic +-- Getting the previous 'Char' isn't enough here - we need to convert it into+-- the same format that 'alexGetByte' would have produced.+--+-- See Note [Unicode in Alex] and #13986.+alexInputPrevChar :: AlexInput -> Char+alexInputPrevChar (AI _ buf) = chr (fromIntegral (adjustChar pc))+ where pc = prevChar buf '\n'++-- backwards compatibility for Alex 2.x+alexGetChar :: AlexInput -> Maybe (Char,AlexInput)+alexGetChar inp = case alexGetByte inp of+ Nothing -> Nothing+ Just (b,i) -> c `seq` Just (c,i)+ where c = chr $ fromIntegral b++-- See Note [Unicode in Alex]+alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)+alexGetByte (AI loc s)+ | atEnd s = Nothing+ | otherwise = byte `seq` loc' `seq` s' `seq`+ --trace (show (ord c)) $+ Just (byte, (AI loc' s'))+ where (c,s') = nextChar s+ loc' = advanceSrcLoc loc c+ byte = adjustChar c+ -- This version does not squash unicode characters, it is used when -- lexing strings. alexGetChar' :: AlexInput -> Maybe (Char,AlexInput)@@ -2179,6 +2277,7 @@ | LambdaCaseBit | BinaryLiteralsBit | NegativeLiteralsBit+ | HexFloatLiteralsBit | TypeApplicationsBit | StaticPointersBit deriving Enum@@ -2241,6 +2340,8 @@ binaryLiteralsEnabled = xtest BinaryLiteralsBit negativeLiteralsEnabled :: ExtsBitmap -> Bool negativeLiteralsEnabled = xtest NegativeLiteralsBit+hexFloatLiteralsEnabled :: ExtsBitmap -> Bool+hexFloatLiteralsEnabled = xtest HexFloatLiteralsBit patternSynonymsEnabled :: ExtsBitmap -> Bool patternSynonymsEnabled = xtest PatternSynonymsBit typeApplicationEnabled :: ExtsBitmap -> Bool@@ -2298,6 +2399,7 @@ .|. LambdaCaseBit `setBitIf` xopt LangExt.LambdaCase flags .|. BinaryLiteralsBit `setBitIf` xopt LangExt.BinaryLiterals flags .|. NegativeLiteralsBit `setBitIf` xopt LangExt.NegativeLiterals flags+ .|. HexFloatLiteralsBit `setBitIf` xopt LangExt.HexFloatLiterals flags .|. PatternSynonymsBit `setBitIf` xopt LangExt.PatternSynonyms flags .|. TypeApplicationsBit `setBitIf` xopt LangExt.TypeApplications flags .|. StaticPointersBit `setBitIf` xopt LangExt.StaticPointers flags@@ -2332,6 +2434,7 @@ alr_context = [], alr_expecting_ocurly = Nothing, alr_justClosedExplicitLetBlock = False,+ use_pos_prags = True, annotations = [], comment_q = [], annotations_comments = []@@ -2388,8 +2491,10 @@ popContext = P $ \ s@(PState{ buffer = buf, options = o, context = ctx, last_len = len, last_loc = last_loc }) -> case ctx of- (_:tl) -> POk s{ context = tl } ()- [] -> PFailed (RealSrcSpan last_loc) (srcParseErr o buf len)+ (_:tl) ->+ POk s{ context = tl } ()+ [] ->+ PFailed (getMessages s) (RealSrcSpan last_loc) (srcParseErr o buf len) -- Push a new layout context at the indentation of the last token read. pushCurrentContext :: GenSemic -> P ()@@ -2427,14 +2532,18 @@ $$ ppWhen (not th_enabled && token == "$") -- #7396 (text "Perhaps you intended to use TemplateHaskell") $$ ppWhen (token == "<-")- (text "Perhaps this statement should be within a 'do' block?")+ (if mdoInLast100+ then text "Perhaps you intended to use RecursiveDo"+ else text "Perhaps this statement should be within a 'do' block?") $$ ppWhen (token == "=") (text "Perhaps you need a 'let' in a 'do' block?" $$ text "e.g. 'let x = 5' instead of 'x = 5'")- $$ ppWhen (not ps_enabled && pattern == "pattern") -- #12429+ $$ ppWhen (not ps_enabled && pattern == "pattern ") -- #12429 (text "Perhaps you intended to use PatternSynonyms") where token = lexemeToString (offsetBytes (-len) buf) len- pattern = lexemeToString (offsetBytes (-len - 8) buf) 7+ pattern = decodePrevNChars 8 buf+ last100 = decodePrevNChars 100 buf+ mdoInLast100 = "mdo" `isInfixOf` last100 th_enabled = extopt LangExt.TemplateHaskell options ps_enabled = extopt LangExt.PatternSynonyms options @@ -2442,9 +2551,9 @@ -- the location of the error. This is the entry point for errors -- detected during parsing. srcParseFail :: P a-srcParseFail = P $ \PState{ buffer = buf, options = o, last_len = len,+srcParseFail = P $ \s@PState{ buffer = buf, options = o, last_len = len, last_loc = last_loc } ->- PFailed (RealSrcSpan last_loc) (srcParseErr o buf len)+ PFailed (getMessages s) (RealSrcSpan last_loc) (srcParseErr o buf len) -- A lexical error is reported at a particular position in the source file, -- not over a token range.@@ -2533,7 +2642,7 @@ (_, ALRLayout _ col : _ls, Just expectingOCurly) | (thisCol > col) || (thisCol == col &&- isNonDecreasingIntentation expectingOCurly) ->+ isNonDecreasingIndentation expectingOCurly) -> do setAlrExpectingOCurly Nothing setALRContext (ALRLayout expectingOCurly thisCol : context) setNextToken t@@ -2677,9 +2786,9 @@ isALRclose ITcubxparen = True isALRclose _ = False -isNonDecreasingIntentation :: ALRLayout -> Bool-isNonDecreasingIntentation ALRLayoutDo = True-isNonDecreasingIntentation _ = False+isNonDecreasingIndentation :: ALRLayout -> Bool+isNonDecreasingIndentation ALRLayoutDo = True+isNonDecreasingIndentation _ = False containsCommas :: Token -> Bool containsCommas IToparen = True@@ -2737,14 +2846,14 @@ lexTokenStream :: StringBuffer -> RealSrcLoc -> DynFlags -> ParseResult [Located Token] lexTokenStream buf loc dflags = unP go initState where dflags' = gopt_set (gopt_unset dflags Opt_Haddock) Opt_KeepRawTokenStream- initState = mkPState dflags' buf loc+ initState = (mkPState dflags' buf loc) { use_pos_prags = False } go = do ltok <- lexer False return case ltok of L _ ITeof -> return [] _ -> liftM (ltok:) go -linePrags = Map.singleton "line" (begin line_prag2)+linePrags = Map.singleton "line" linePrag fileHeaderPrags = Map.fromList([("options", lex_string_prag IToptions_prag), ("options_ghc", lex_string_prag IToptions_prag),@@ -2789,7 +2898,7 @@ ("incoherent", strtoken (\s -> ITincoherent_prag (SourceText s))), ("ctype", strtoken (\s -> ITctype (SourceText s))), ("complete", strtoken (\s -> ITcomplete_prag (SourceText s))),- ("column", begin column_prag)+ ("column", columnPrag) ] twoWordPrags = Map.fromList([@@ -3102,22 +3211,24 @@ alex_action_97 = tok_num negative 3 3 hexadecimal alex_action_98 = strtoken tok_float alex_action_99 = strtoken tok_float -alex_action_100 = tok_primint positive 0 1 decimal -alex_action_101 = tok_primint positive 2 3 binary -alex_action_102 = tok_primint positive 2 3 octal -alex_action_103 = tok_primint positive 2 3 hexadecimal -alex_action_104 = tok_primint negative 1 2 decimal -alex_action_105 = tok_primint negative 3 4 binary -alex_action_106 = tok_primint negative 3 4 octal -alex_action_107 = tok_primint negative 3 4 hexadecimal -alex_action_108 = tok_primword 0 2 decimal -alex_action_109 = tok_primword 2 4 binary -alex_action_110 = tok_primword 2 4 octal -alex_action_111 = tok_primword 2 4 hexadecimal -alex_action_112 = init_strtoken 1 tok_primfloat -alex_action_113 = init_strtoken 2 tok_primdouble -alex_action_114 = lex_char_tok -alex_action_115 = lex_string_tok +alex_action_100 = strtoken tok_hex_float +alex_action_101 = strtoken tok_hex_float +alex_action_102 = tok_primint positive 0 1 decimal +alex_action_103 = tok_primint positive 2 3 binary +alex_action_104 = tok_primint positive 2 3 octal +alex_action_105 = tok_primint positive 2 3 hexadecimal +alex_action_106 = tok_primint negative 1 2 decimal +alex_action_107 = tok_primint negative 3 4 binary +alex_action_108 = tok_primint negative 3 4 octal +alex_action_109 = tok_primint negative 3 4 hexadecimal +alex_action_110 = tok_primword 0 2 decimal +alex_action_111 = tok_primword 2 4 binary +alex_action_112 = tok_primword 2 4 octal +alex_action_113 = tok_primword 2 4 hexadecimal +alex_action_114 = init_strtoken 1 tok_primfloat +alex_action_115 = init_strtoken 2 tok_primdouble +alex_action_116 = lex_char_tok +alex_action_117 = lex_string_tok {-# LINE 1 "templates/GenericTemplate.hs" #-} -- ----------------------------------------------------------------------------- -- ALEX TEMPLATE
dist/build/Parser.hs view
@@ -78,11940 +78,12009 @@ -- compiler/utils import Util ( looksLikePackageName )-import Prelude--import qualified GHC.LanguageExtensions as LangExt-import qualified Data.Array as Happy_Data_Array-import qualified Data.Bits as Bits-import qualified GHC.Exts as Happy_GHC_Exts-import Control.Applicative(Applicative(..))-import Control.Monad (ap)---- parser produced by Happy Version 1.19.9--newtype HappyAbsSyn = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = Happy_GHC_Exts.Any-#else-type HappyAny = forall a . a-#endif-happyIn16 :: (Located RdrName) -> (HappyAbsSyn )-happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut16 #-}-happyIn17 :: ([LHsUnit PackageName]) -> (HappyAbsSyn )-happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn ) -> ([LHsUnit PackageName])-happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut17 #-}-happyIn18 :: (OrdList (LHsUnit PackageName)) -> (HappyAbsSyn )-happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn ) -> (OrdList (LHsUnit PackageName))-happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut18 #-}-happyIn19 :: (LHsUnit PackageName) -> (HappyAbsSyn )-happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn ) -> (LHsUnit PackageName)-happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut19 #-}-happyIn20 :: (LHsUnitId PackageName) -> (HappyAbsSyn )-happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn ) -> (LHsUnitId PackageName)-happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut20 #-}-happyIn21 :: (OrdList (LHsModuleSubst PackageName)) -> (HappyAbsSyn )-happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn ) -> (OrdList (LHsModuleSubst PackageName))-happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut21 #-}-happyIn22 :: (LHsModuleSubst PackageName) -> (HappyAbsSyn )-happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn ) -> (LHsModuleSubst PackageName)-happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut22 #-}-happyIn23 :: (LHsModuleId PackageName) -> (HappyAbsSyn )-happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn ) -> (LHsModuleId PackageName)-happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut23 #-}-happyIn24 :: (Located PackageName) -> (HappyAbsSyn )-happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn ) -> (Located PackageName)-happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut24 #-}-happyIn25 :: (Located FastString) -> (HappyAbsSyn )-happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn ) -> (Located FastString)-happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut25 #-}-happyIn26 :: (Located FastString) -> (HappyAbsSyn )-happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn26 #-}-happyOut26 :: (HappyAbsSyn ) -> (Located FastString)-happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut26 #-}-happyIn27 :: (Maybe [LRenaming]) -> (HappyAbsSyn )-happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn27 #-}-happyOut27 :: (HappyAbsSyn ) -> (Maybe [LRenaming])-happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut27 #-}-happyIn28 :: (OrdList LRenaming) -> (HappyAbsSyn )-happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn28 #-}-happyOut28 :: (HappyAbsSyn ) -> (OrdList LRenaming)-happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut28 #-}-happyIn29 :: (LRenaming) -> (HappyAbsSyn )-happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn29 #-}-happyOut29 :: (HappyAbsSyn ) -> (LRenaming)-happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut29 #-}-happyIn30 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )-happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn30 #-}-happyOut30 :: (HappyAbsSyn ) -> (OrdList (LHsUnitDecl PackageName))-happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut30 #-}-happyIn31 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )-happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn31 #-}-happyOut31 :: (HappyAbsSyn ) -> (OrdList (LHsUnitDecl PackageName))-happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut31 #-}-happyIn32 :: (LHsUnitDecl PackageName) -> (HappyAbsSyn )-happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn32 #-}-happyOut32 :: (HappyAbsSyn ) -> (LHsUnitDecl PackageName)-happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut32 #-}-happyIn33 :: (Located (HsModule RdrName)) -> (HappyAbsSyn )-happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn33 #-}-happyOut33 :: (HappyAbsSyn ) -> (Located (HsModule RdrName))-happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut33 #-}-happyIn34 :: (Located (HsModule RdrName)) -> (HappyAbsSyn )-happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn34 #-}-happyOut34 :: (HappyAbsSyn ) -> (Located (HsModule RdrName))-happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut34 #-}-happyIn35 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn35 #-}-happyOut35 :: (HappyAbsSyn ) -> (Maybe LHsDocString)-happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut35 #-}-happyIn36 :: (()) -> (HappyAbsSyn )-happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn36 #-}-happyOut36 :: (HappyAbsSyn ) -> (())-happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut36 #-}-happyIn37 :: (()) -> (HappyAbsSyn )-happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn37 #-}-happyOut37 :: (HappyAbsSyn ) -> (())-happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut37 #-}-happyIn38 :: (Maybe (Located WarningTxt)) -> (HappyAbsSyn )-happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn38 #-}-happyOut38 :: (HappyAbsSyn ) -> (Maybe (Located WarningTxt))-happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut38 #-}-happyIn39 :: (([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName]))) -> (HappyAbsSyn )-happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn39 #-}-happyOut39 :: (HappyAbsSyn ) -> (([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName])))-happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut39 #-}-happyIn40 :: (([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName]))) -> (HappyAbsSyn )-happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn40 #-}-happyOut40 :: (HappyAbsSyn ) -> (([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName])))-happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut40 #-}-happyIn41 :: (([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName]))) -> (HappyAbsSyn )-happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn41 #-}-happyOut41 :: (HappyAbsSyn ) -> (([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName])))-happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut41 #-}-happyIn42 :: (([LImportDecl RdrName], [LHsDecl RdrName])) -> (HappyAbsSyn )-happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn42 #-}-happyOut42 :: (HappyAbsSyn ) -> (([LImportDecl RdrName], [LHsDecl RdrName]))-happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut42 #-}-happyIn43 :: (Located (HsModule RdrName)) -> (HappyAbsSyn )-happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn43 #-}-happyOut43 :: (HappyAbsSyn ) -> (Located (HsModule RdrName))-happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut43 #-}-happyIn44 :: ([LImportDecl RdrName]) -> (HappyAbsSyn )-happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn44 #-}-happyOut44 :: (HappyAbsSyn ) -> ([LImportDecl RdrName])-happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut44 #-}-happyIn45 :: ([LImportDecl RdrName]) -> (HappyAbsSyn )-happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn45 #-}-happyOut45 :: (HappyAbsSyn ) -> ([LImportDecl RdrName])-happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut45 #-}-happyIn46 :: ([LImportDecl RdrName]) -> (HappyAbsSyn )-happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn46 #-}-happyOut46 :: (HappyAbsSyn ) -> ([LImportDecl RdrName])-happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut46 #-}-happyIn47 :: ([LImportDecl RdrName]) -> (HappyAbsSyn )-happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn47 #-}-happyOut47 :: (HappyAbsSyn ) -> ([LImportDecl RdrName])-happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut47 #-}-happyIn48 :: ((Maybe (Located [LIE RdrName]))) -> (HappyAbsSyn )-happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn48 #-}-happyOut48 :: (HappyAbsSyn ) -> ((Maybe (Located [LIE RdrName])))-happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut48 #-}-happyIn49 :: (OrdList (LIE RdrName)) -> (HappyAbsSyn )-happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn49 #-}-happyOut49 :: (HappyAbsSyn ) -> (OrdList (LIE RdrName))-happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut49 #-}-happyIn50 :: (OrdList (LIE RdrName)) -> (HappyAbsSyn )-happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn50 #-}-happyOut50 :: (HappyAbsSyn ) -> (OrdList (LIE RdrName))-happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut50 #-}-happyIn51 :: (OrdList (LIE RdrName)) -> (HappyAbsSyn )-happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn51 #-}-happyOut51 :: (HappyAbsSyn ) -> (OrdList (LIE RdrName))-happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut51 #-}-happyIn52 :: (OrdList (LIE RdrName)) -> (HappyAbsSyn )-happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn52 #-}-happyOut52 :: (HappyAbsSyn ) -> (OrdList (LIE RdrName))-happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut52 #-}-happyIn53 :: (OrdList (LIE RdrName)) -> (HappyAbsSyn )-happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn53 #-}-happyOut53 :: (HappyAbsSyn ) -> (OrdList (LIE RdrName))-happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut53 #-}-happyIn54 :: (Located ([AddAnn],ImpExpSubSpec)) -> (HappyAbsSyn )-happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn54 #-}-happyOut54 :: (HappyAbsSyn ) -> (Located ([AddAnn],ImpExpSubSpec))-happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut54 #-}-happyIn55 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )-happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn55 #-}-happyOut55 :: (HappyAbsSyn ) -> (([AddAnn], [Located ImpExpQcSpec]))-happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut55 #-}-happyIn56 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )-happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn56 #-}-happyOut56 :: (HappyAbsSyn ) -> (([AddAnn], [Located ImpExpQcSpec]))-happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut56 #-}-happyIn57 :: (Located ([AddAnn], Located ImpExpQcSpec)) -> (HappyAbsSyn )-happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn57 #-}-happyOut57 :: (HappyAbsSyn ) -> (Located ([AddAnn], Located ImpExpQcSpec))-happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut57 #-}-happyIn58 :: (Located ImpExpQcSpec) -> (HappyAbsSyn )-happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn58 #-}-happyOut58 :: (HappyAbsSyn ) -> (Located ImpExpQcSpec)-happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut58 #-}-happyIn59 :: (Located RdrName) -> (HappyAbsSyn )-happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn59 #-}-happyOut59 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut59 #-}-happyIn60 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn60 #-}-happyOut60 :: (HappyAbsSyn ) -> ([AddAnn])-happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut60 #-}-happyIn61 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn61 #-}-happyOut61 :: (HappyAbsSyn ) -> ([AddAnn])-happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut61 #-}-happyIn62 :: ([LImportDecl RdrName]) -> (HappyAbsSyn )-happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn62 #-}-happyOut62 :: (HappyAbsSyn ) -> ([LImportDecl RdrName])-happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut62 #-}-happyIn63 :: ([LImportDecl RdrName]) -> (HappyAbsSyn )-happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn63 #-}-happyOut63 :: (HappyAbsSyn ) -> ([LImportDecl RdrName])-happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut63 #-}-happyIn64 :: (LImportDecl RdrName) -> (HappyAbsSyn )-happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn64 #-}-happyOut64 :: (HappyAbsSyn ) -> (LImportDecl RdrName)-happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut64 #-}-happyIn65 :: ((([AddAnn],SourceText),IsBootInterface)) -> (HappyAbsSyn )-happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn65 #-}-happyOut65 :: (HappyAbsSyn ) -> ((([AddAnn],SourceText),IsBootInterface))-happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut65 #-}-happyIn66 :: (([AddAnn],Bool)) -> (HappyAbsSyn )-happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn66 #-}-happyOut66 :: (HappyAbsSyn ) -> (([AddAnn],Bool))-happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut66 #-}-happyIn67 :: (([AddAnn],Maybe StringLiteral)) -> (HappyAbsSyn )-happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn67 #-}-happyOut67 :: (HappyAbsSyn ) -> (([AddAnn],Maybe StringLiteral))-happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut67 #-}-happyIn68 :: (([AddAnn],Bool)) -> (HappyAbsSyn )-happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn68 #-}-happyOut68 :: (HappyAbsSyn ) -> (([AddAnn],Bool))-happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut68 #-}-happyIn69 :: (([AddAnn],Located (Maybe (Located ModuleName)))) -> (HappyAbsSyn )-happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn69 #-}-happyOut69 :: (HappyAbsSyn ) -> (([AddAnn],Located (Maybe (Located ModuleName))))-happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut69 #-}-happyIn70 :: (Located (Maybe (Bool, Located [LIE RdrName]))) -> (HappyAbsSyn )-happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn70 #-}-happyOut70 :: (HappyAbsSyn ) -> (Located (Maybe (Bool, Located [LIE RdrName])))-happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut70 #-}-happyIn71 :: (Located (Bool, Located [LIE RdrName])) -> (HappyAbsSyn )-happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn71 #-}-happyOut71 :: (HappyAbsSyn ) -> (Located (Bool, Located [LIE RdrName]))-happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut71 #-}-happyIn72 :: (Located (SourceText,Int)) -> (HappyAbsSyn )-happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn72 #-}-happyOut72 :: (HappyAbsSyn ) -> (Located (SourceText,Int))-happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut72 #-}-happyIn73 :: (Located FixityDirection) -> (HappyAbsSyn )-happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn73 #-}-happyOut73 :: (HappyAbsSyn ) -> (Located FixityDirection)-happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut73 #-}-happyIn74 :: (Located (OrdList (Located RdrName))) -> (HappyAbsSyn )-happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn74 #-}-happyOut74 :: (HappyAbsSyn ) -> (Located (OrdList (Located RdrName)))-happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut74 #-}-happyIn75 :: (OrdList (LHsDecl RdrName)) -> (HappyAbsSyn )-happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn75 #-}-happyOut75 :: (HappyAbsSyn ) -> (OrdList (LHsDecl RdrName))-happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut75 #-}-happyIn76 :: (OrdList (LHsDecl RdrName)) -> (HappyAbsSyn )-happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn76 #-}-happyOut76 :: (HappyAbsSyn ) -> (OrdList (LHsDecl RdrName))-happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut76 #-}-happyIn77 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn77 #-}-happyOut77 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut77 #-}-happyIn78 :: (LTyClDecl RdrName) -> (HappyAbsSyn )-happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn78 #-}-happyOut78 :: (HappyAbsSyn ) -> (LTyClDecl RdrName)-happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut78 #-}-happyIn79 :: (LTyClDecl RdrName) -> (HappyAbsSyn )-happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn79 #-}-happyOut79 :: (HappyAbsSyn ) -> (LTyClDecl RdrName)-happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut79 #-}-happyIn80 :: (LInstDecl RdrName) -> (HappyAbsSyn )-happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn80 #-}-happyOut80 :: (HappyAbsSyn ) -> (LInstDecl RdrName)-happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut80 #-}-happyIn81 :: (Maybe (Located OverlapMode)) -> (HappyAbsSyn )-happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn81 #-}-happyOut81 :: (HappyAbsSyn ) -> (Maybe (Located OverlapMode))-happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut81 #-}-happyIn82 :: (Maybe (Located DerivStrategy)) -> (HappyAbsSyn )-happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn82 #-}-happyOut82 :: (HappyAbsSyn ) -> (Maybe (Located DerivStrategy))-happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut82 #-}-happyIn83 :: (Located ([AddAnn], Maybe (LInjectivityAnn RdrName))) -> (HappyAbsSyn )-happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn83 #-}-happyOut83 :: (HappyAbsSyn ) -> (Located ([AddAnn], Maybe (LInjectivityAnn RdrName)))-happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut83 #-}-happyIn84 :: (LInjectivityAnn RdrName) -> (HappyAbsSyn )-happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn84 #-}-happyOut84 :: (HappyAbsSyn ) -> (LInjectivityAnn RdrName)-happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut84 #-}-happyIn85 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn85 #-}-happyOut85 :: (HappyAbsSyn ) -> (Located [Located RdrName])-happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut85 #-}-happyIn86 :: (Located ([AddAnn],FamilyInfo RdrName)) -> (HappyAbsSyn )-happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn86 #-}-happyOut86 :: (HappyAbsSyn ) -> (Located ([AddAnn],FamilyInfo RdrName))-happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut86 #-}-happyIn87 :: (Located ([AddAnn],Maybe [LTyFamInstEqn RdrName])) -> (HappyAbsSyn )-happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn87 #-}-happyOut87 :: (HappyAbsSyn ) -> (Located ([AddAnn],Maybe [LTyFamInstEqn RdrName]))-happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut87 #-}-happyIn88 :: (Located [LTyFamInstEqn RdrName]) -> (HappyAbsSyn )-happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn88 #-}-happyOut88 :: (HappyAbsSyn ) -> (Located [LTyFamInstEqn RdrName])-happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut88 #-}-happyIn89 :: (Located ([AddAnn],LTyFamInstEqn RdrName)) -> (HappyAbsSyn )-happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn89 #-}-happyOut89 :: (HappyAbsSyn ) -> (Located ([AddAnn],LTyFamInstEqn RdrName))-happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut89 #-}-happyIn90 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn90 #-}-happyOut90 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut90 #-}-happyIn91 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn91 #-}-happyOut91 :: (HappyAbsSyn ) -> ([AddAnn])-happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut91 #-}-happyIn92 :: (LInstDecl RdrName) -> (HappyAbsSyn )-happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn92 #-}-happyOut92 :: (HappyAbsSyn ) -> (LInstDecl RdrName)-happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut92 #-}-happyIn93 :: (Located (AddAnn, NewOrData)) -> (HappyAbsSyn )-happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn93 #-}-happyOut93 :: (HappyAbsSyn ) -> (Located (AddAnn, NewOrData))-happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut93 #-}-happyIn94 :: (Located ([AddAnn], Maybe (LHsKind RdrName))) -> (HappyAbsSyn )-happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn94 #-}-happyOut94 :: (HappyAbsSyn ) -> (Located ([AddAnn], Maybe (LHsKind RdrName)))-happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut94 #-}-happyIn95 :: (Located ([AddAnn], LFamilyResultSig RdrName)) -> (HappyAbsSyn )-happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn95 #-}-happyOut95 :: (HappyAbsSyn ) -> (Located ([AddAnn], LFamilyResultSig RdrName))-happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut95 #-}-happyIn96 :: (Located ([AddAnn], LFamilyResultSig RdrName)) -> (HappyAbsSyn )-happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn96 #-}-happyOut96 :: (HappyAbsSyn ) -> (Located ([AddAnn], LFamilyResultSig RdrName))-happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut96 #-}-happyIn97 :: (Located ([AddAnn], ( LFamilyResultSig RdrName- , Maybe (LInjectivityAnn RdrName)))) -> (HappyAbsSyn )-happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn97 #-}-happyOut97 :: (HappyAbsSyn ) -> (Located ([AddAnn], ( LFamilyResultSig RdrName- , Maybe (LInjectivityAnn RdrName))))-happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut97 #-}-happyIn98 :: (Located (Maybe (LHsContext RdrName), LHsType RdrName)) -> (HappyAbsSyn )-happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn98 #-}-happyOut98 :: (HappyAbsSyn ) -> (Located (Maybe (LHsContext RdrName), LHsType RdrName))-happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut98 #-}-happyIn99 :: (Maybe (Located CType)) -> (HappyAbsSyn )-happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn99 #-}-happyOut99 :: (HappyAbsSyn ) -> (Maybe (Located CType))-happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut99 #-}-happyIn100 :: (LDerivDecl RdrName) -> (HappyAbsSyn )-happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn100 #-}-happyOut100 :: (HappyAbsSyn ) -> (LDerivDecl RdrName)-happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut100 #-}-happyIn101 :: (LRoleAnnotDecl RdrName) -> (HappyAbsSyn )-happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn101 #-}-happyOut101 :: (HappyAbsSyn ) -> (LRoleAnnotDecl RdrName)-happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut101 #-}-happyIn102 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )-happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn102 #-}-happyOut102 :: (HappyAbsSyn ) -> (Located [Located (Maybe FastString)])-happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut102 #-}-happyIn103 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )-happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn103 #-}-happyOut103 :: (HappyAbsSyn ) -> (Located [Located (Maybe FastString)])-happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut103 #-}-happyIn104 :: (Located (Maybe FastString)) -> (HappyAbsSyn )-happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn104 #-}-happyOut104 :: (HappyAbsSyn ) -> (Located (Maybe FastString))-happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut104 #-}-happyIn105 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn105 #-}-happyOut105 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut105 #-}-happyIn106 :: ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])) -> (HappyAbsSyn )-happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn106 #-}-happyOut106 :: (HappyAbsSyn ) -> ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]))-happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut106 #-}-happyIn107 :: ([Located RdrName]) -> (HappyAbsSyn )-happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn107 #-}-happyOut107 :: (HappyAbsSyn ) -> ([Located RdrName])-happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut107 #-}-happyIn108 :: ([RecordPatSynField (Located RdrName)]) -> (HappyAbsSyn )-happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn108 #-}-happyOut108 :: (HappyAbsSyn ) -> ([RecordPatSynField (Located RdrName)])-happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut108 #-}-happyIn109 :: (Located ([AddAnn]- , Located (OrdList (LHsDecl RdrName)))) -> (HappyAbsSyn )-happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn109 #-}-happyOut109 :: (HappyAbsSyn ) -> (Located ([AddAnn]- , Located (OrdList (LHsDecl RdrName))))-happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut109 #-}-happyIn110 :: (LSig RdrName) -> (HappyAbsSyn )-happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn110 #-}-happyOut110 :: (HappyAbsSyn ) -> (LSig RdrName)-happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut110 #-}-happyIn111 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn111 #-}-happyOut111 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut111 #-}-happyIn112 :: (Located ([AddAnn],OrdList (LHsDecl RdrName))) -> (HappyAbsSyn )-happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn112 #-}-happyOut112 :: (HappyAbsSyn ) -> (Located ([AddAnn],OrdList (LHsDecl RdrName)))-happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut112 #-}-happyIn113 :: (Located ([AddAnn]- , OrdList (LHsDecl RdrName))) -> (HappyAbsSyn )-happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn113 #-}-happyOut113 :: (HappyAbsSyn ) -> (Located ([AddAnn]- , OrdList (LHsDecl RdrName)))-happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut113 #-}-happyIn114 :: (Located ([AddAnn]- ,(OrdList (LHsDecl RdrName)))) -> (HappyAbsSyn )-happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn114 #-}-happyOut114 :: (HappyAbsSyn ) -> (Located ([AddAnn]- ,(OrdList (LHsDecl RdrName))))-happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut114 #-}-happyIn115 :: (Located (OrdList (LHsDecl RdrName))) -> (HappyAbsSyn )-happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn115 #-}-happyOut115 :: (HappyAbsSyn ) -> (Located (OrdList (LHsDecl RdrName)))-happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut115 #-}-happyIn116 :: (Located ([AddAnn],OrdList (LHsDecl RdrName))) -> (HappyAbsSyn )-happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn116 #-}-happyOut116 :: (HappyAbsSyn ) -> (Located ([AddAnn],OrdList (LHsDecl RdrName)))-happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut116 #-}-happyIn117 :: (Located ([AddAnn]- , OrdList (LHsDecl RdrName))) -> (HappyAbsSyn )-happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn117 #-}-happyOut117 :: (HappyAbsSyn ) -> (Located ([AddAnn]- , OrdList (LHsDecl RdrName)))-happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut117 #-}-happyIn118 :: (Located ([AddAnn]- , OrdList (LHsDecl RdrName))) -> (HappyAbsSyn )-happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn118 #-}-happyOut118 :: (HappyAbsSyn ) -> (Located ([AddAnn]- , OrdList (LHsDecl RdrName)))-happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut118 #-}-happyIn119 :: (Located ([AddAnn],OrdList (LHsDecl RdrName))) -> (HappyAbsSyn )-happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn119 #-}-happyOut119 :: (HappyAbsSyn ) -> (Located ([AddAnn],OrdList (LHsDecl RdrName)))-happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut119 #-}-happyIn120 :: (Located ([AddAnn],Located (OrdList (LHsDecl RdrName)))) -> (HappyAbsSyn )-happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn120 #-}-happyOut120 :: (HappyAbsSyn ) -> (Located ([AddAnn],Located (OrdList (LHsDecl RdrName))))-happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut120 #-}-happyIn121 :: (Located ([AddAnn],Located (HsLocalBinds RdrName))) -> (HappyAbsSyn )-happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn121 #-}-happyOut121 :: (HappyAbsSyn ) -> (Located ([AddAnn],Located (HsLocalBinds RdrName)))-happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut121 #-}-happyIn122 :: (Located ([AddAnn],Located (HsLocalBinds RdrName))) -> (HappyAbsSyn )-happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn122 #-}-happyOut122 :: (HappyAbsSyn ) -> (Located ([AddAnn],Located (HsLocalBinds RdrName)))-happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut122 #-}-happyIn123 :: (OrdList (LRuleDecl RdrName)) -> (HappyAbsSyn )-happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn123 #-}-happyOut123 :: (HappyAbsSyn ) -> (OrdList (LRuleDecl RdrName))-happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut123 #-}-happyIn124 :: (LRuleDecl RdrName) -> (HappyAbsSyn )-happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn124 #-}-happyOut124 :: (HappyAbsSyn ) -> (LRuleDecl RdrName)-happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut124 #-}-happyIn125 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )-happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn125 #-}-happyOut125 :: (HappyAbsSyn ) -> (([AddAnn],Maybe Activation))-happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut125 #-}-happyIn126 :: (([AddAnn]- ,Activation)) -> (HappyAbsSyn )-happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn126 #-}-happyOut126 :: (HappyAbsSyn ) -> (([AddAnn]- ,Activation))-happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut126 #-}-happyIn127 :: (([AddAnn],[LRuleBndr RdrName])) -> (HappyAbsSyn )-happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn127 #-}-happyOut127 :: (HappyAbsSyn ) -> (([AddAnn],[LRuleBndr RdrName]))-happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut127 #-}-happyIn128 :: ([LRuleBndr RdrName]) -> (HappyAbsSyn )-happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn128 #-}-happyOut128 :: (HappyAbsSyn ) -> ([LRuleBndr RdrName])-happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut128 #-}-happyIn129 :: (LRuleBndr RdrName) -> (HappyAbsSyn )-happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn129 #-}-happyOut129 :: (HappyAbsSyn ) -> (LRuleBndr RdrName)-happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut129 #-}-happyIn130 :: (OrdList (LWarnDecl RdrName)) -> (HappyAbsSyn )-happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn130 #-}-happyOut130 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl RdrName))-happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut130 #-}-happyIn131 :: (OrdList (LWarnDecl RdrName)) -> (HappyAbsSyn )-happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn131 #-}-happyOut131 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl RdrName))-happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut131 #-}-happyIn132 :: (OrdList (LWarnDecl RdrName)) -> (HappyAbsSyn )-happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn132 #-}-happyOut132 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl RdrName))-happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut132 #-}-happyIn133 :: (OrdList (LWarnDecl RdrName)) -> (HappyAbsSyn )-happyIn133 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn133 #-}-happyOut133 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl RdrName))-happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut133 #-}-happyIn134 :: (Located ([AddAnn],[Located StringLiteral])) -> (HappyAbsSyn )-happyIn134 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn134 #-}-happyOut134 :: (HappyAbsSyn ) -> (Located ([AddAnn],[Located StringLiteral]))-happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut134 #-}-happyIn135 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )-happyIn135 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn135 #-}-happyOut135 :: (HappyAbsSyn ) -> (Located (OrdList (Located StringLiteral)))-happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut135 #-}-happyIn136 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn136 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn136 #-}-happyOut136 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut136 #-}-happyIn137 :: (Located ([AddAnn],HsDecl RdrName)) -> (HappyAbsSyn )-happyIn137 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn137 #-}-happyOut137 :: (HappyAbsSyn ) -> (Located ([AddAnn],HsDecl RdrName))-happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut137 #-}-happyIn138 :: (Located CCallConv) -> (HappyAbsSyn )-happyIn138 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn138 #-}-happyOut138 :: (HappyAbsSyn ) -> (Located CCallConv)-happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut138 #-}-happyIn139 :: (Located Safety) -> (HappyAbsSyn )-happyIn139 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn139 #-}-happyOut139 :: (HappyAbsSyn ) -> (Located Safety)-happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut139 #-}-happyIn140 :: (Located ([AddAnn]- ,(Located StringLiteral, Located RdrName, LHsSigType RdrName))) -> (HappyAbsSyn )-happyIn140 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn140 #-}-happyOut140 :: (HappyAbsSyn ) -> (Located ([AddAnn]- ,(Located StringLiteral, Located RdrName, LHsSigType RdrName)))-happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut140 #-}-happyIn141 :: (([AddAnn], Maybe (LHsType RdrName))) -> (HappyAbsSyn )-happyIn141 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn141 #-}-happyOut141 :: (HappyAbsSyn ) -> (([AddAnn], Maybe (LHsType RdrName)))-happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut141 #-}-happyIn142 :: (([AddAnn],Maybe (LHsType RdrName))) -> (HappyAbsSyn )-happyIn142 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn142 #-}-happyOut142 :: (HappyAbsSyn ) -> (([AddAnn],Maybe (LHsType RdrName)))-happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut142 #-}-happyIn143 :: (([AddAnn], Maybe (Located RdrName))) -> (HappyAbsSyn )-happyIn143 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn143 #-}-happyOut143 :: (HappyAbsSyn ) -> (([AddAnn], Maybe (Located RdrName)))-happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut143 #-}-happyIn144 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn144 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn144 #-}-happyOut144 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut144 #-}-happyIn145 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn145 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn145 #-}-happyOut145 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut145 #-}-happyIn146 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn146 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn146 #-}-happyOut146 :: (HappyAbsSyn ) -> (Located [Located RdrName])-happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut146 #-}-happyIn147 :: ((OrdList (LHsSigType RdrName))) -> (HappyAbsSyn )-happyIn147 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn147 #-}-happyOut147 :: (HappyAbsSyn ) -> ((OrdList (LHsSigType RdrName)))-happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut147 #-}-happyIn148 :: (Located ([AddAnn],HsSrcBang)) -> (HappyAbsSyn )-happyIn148 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn148 #-}-happyOut148 :: (HappyAbsSyn ) -> (Located ([AddAnn],HsSrcBang))-happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut148 #-}-happyIn149 :: (Located ([AddAnn], SrcStrictness)) -> (HappyAbsSyn )-happyIn149 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn149 #-}-happyOut149 :: (HappyAbsSyn ) -> (Located ([AddAnn], SrcStrictness))-happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut149 #-}-happyIn150 :: (Located ([AddAnn], SourceText, SrcUnpackedness)) -> (HappyAbsSyn )-happyIn150 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn150 #-}-happyOut150 :: (HappyAbsSyn ) -> (Located ([AddAnn], SourceText, SrcUnpackedness))-happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut150 #-}-happyIn151 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn151 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn151 #-}-happyOut151 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut151 #-}-happyIn152 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn152 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn152 #-}-happyOut152 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut152 #-}-happyIn153 :: (LHsContext RdrName) -> (HappyAbsSyn )-happyIn153 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn153 #-}-happyOut153 :: (HappyAbsSyn ) -> (LHsContext RdrName)-happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut153 #-}-happyIn154 :: (LHsContext RdrName) -> (HappyAbsSyn )-happyIn154 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn154 #-}-happyOut154 :: (HappyAbsSyn ) -> (LHsContext RdrName)-happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut154 #-}-happyIn155 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn155 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn155 #-}-happyOut155 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut155 #-}-happyIn156 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn156 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn156 #-}-happyOut156 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut156 #-}-happyIn157 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn157 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn157 #-}-happyOut157 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut157 #-}-happyIn158 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn158 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn158 #-}-happyOut158 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut158 #-}-happyIn159 :: (Located [LHsAppType RdrName]) -> (HappyAbsSyn )-happyIn159 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn159 #-}-happyOut159 :: (HappyAbsSyn ) -> (Located [LHsAppType RdrName])-happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut159 #-}-happyIn160 :: (LHsAppType RdrName) -> (HappyAbsSyn )-happyIn160 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn160 #-}-happyOut160 :: (HappyAbsSyn ) -> (LHsAppType RdrName)-happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut160 #-}-happyIn161 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn161 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn161 #-}-happyOut161 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut161 #-}-happyIn162 :: (LHsSigType RdrName) -> (HappyAbsSyn )-happyIn162 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn162 #-}-happyOut162 :: (HappyAbsSyn ) -> (LHsSigType RdrName)-happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut162 #-}-happyIn163 :: ([LHsSigType RdrName]) -> (HappyAbsSyn )-happyIn163 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn163 #-}-happyOut163 :: (HappyAbsSyn ) -> ([LHsSigType RdrName])-happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut163 #-}-happyIn164 :: ([LHsType RdrName]) -> (HappyAbsSyn )-happyIn164 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn164 #-}-happyOut164 :: (HappyAbsSyn ) -> ([LHsType RdrName])-happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut164 #-}-happyIn165 :: ([LHsType RdrName]) -> (HappyAbsSyn )-happyIn165 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn165 #-}-happyOut165 :: (HappyAbsSyn ) -> ([LHsType RdrName])-happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut165 #-}-happyIn166 :: ([LHsType RdrName]) -> (HappyAbsSyn )-happyIn166 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn166 #-}-happyOut166 :: (HappyAbsSyn ) -> ([LHsType RdrName])-happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut166 #-}-happyIn167 :: ([LHsTyVarBndr RdrName]) -> (HappyAbsSyn )-happyIn167 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn167 #-}-happyOut167 :: (HappyAbsSyn ) -> ([LHsTyVarBndr RdrName])-happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut167 #-}-happyIn168 :: (LHsTyVarBndr RdrName) -> (HappyAbsSyn )-happyIn168 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn168 #-}-happyOut168 :: (HappyAbsSyn ) -> (LHsTyVarBndr RdrName)-happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut168 #-}-happyIn169 :: (Located ([AddAnn],[Located (FunDep (Located RdrName))])) -> (HappyAbsSyn )-happyIn169 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn169 #-}-happyOut169 :: (HappyAbsSyn ) -> (Located ([AddAnn],[Located (FunDep (Located RdrName))]))-happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut169 #-}-happyIn170 :: (Located [Located (FunDep (Located RdrName))]) -> (HappyAbsSyn )-happyIn170 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn170 #-}-happyOut170 :: (HappyAbsSyn ) -> (Located [Located (FunDep (Located RdrName))])-happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut170 #-}-happyIn171 :: (Located (FunDep (Located RdrName))) -> (HappyAbsSyn )-happyIn171 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn171 #-}-happyOut171 :: (HappyAbsSyn ) -> (Located (FunDep (Located RdrName)))-happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut171 #-}-happyIn172 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn172 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn172 #-}-happyOut172 :: (HappyAbsSyn ) -> (Located [Located RdrName])-happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut172 #-}-happyIn173 :: (LHsKind RdrName) -> (HappyAbsSyn )-happyIn173 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn173 #-}-happyOut173 :: (HappyAbsSyn ) -> (LHsKind RdrName)-happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut173 #-}-happyIn174 :: (Located ([AddAnn]- ,[LConDecl RdrName])) -> (HappyAbsSyn )-happyIn174 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn174 #-}-happyOut174 :: (HappyAbsSyn ) -> (Located ([AddAnn]- ,[LConDecl RdrName]))-happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut174 #-}-happyIn175 :: (Located [LConDecl RdrName]) -> (HappyAbsSyn )-happyIn175 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn175 #-}-happyOut175 :: (HappyAbsSyn ) -> (Located [LConDecl RdrName])-happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut175 #-}-happyIn176 :: (LConDecl RdrName) -> (HappyAbsSyn )-happyIn176 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn176 #-}-happyOut176 :: (HappyAbsSyn ) -> (LConDecl RdrName)-happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut176 #-}-happyIn177 :: (LConDecl RdrName) -> (HappyAbsSyn )-happyIn177 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn177 #-}-happyOut177 :: (HappyAbsSyn ) -> (LConDecl RdrName)-happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut177 #-}-happyIn178 :: (Located ([AddAnn],[LConDecl RdrName])) -> (HappyAbsSyn )-happyIn178 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn178 #-}-happyOut178 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LConDecl RdrName]))-happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut178 #-}-happyIn179 :: (Located [LConDecl RdrName]) -> (HappyAbsSyn )-happyIn179 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn179 #-}-happyOut179 :: (HappyAbsSyn ) -> (Located [LConDecl RdrName])-happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut179 #-}-happyIn180 :: (LConDecl RdrName) -> (HappyAbsSyn )-happyIn180 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn180 #-}-happyOut180 :: (HappyAbsSyn ) -> (LConDecl RdrName)-happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut180 #-}-happyIn181 :: (Located ([AddAnn], Maybe [LHsTyVarBndr RdrName])) -> (HappyAbsSyn )-happyIn181 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn181 #-}-happyOut181 :: (HappyAbsSyn ) -> (Located ([AddAnn], Maybe [LHsTyVarBndr RdrName]))-happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut181 #-}-happyIn182 :: (Located (Located RdrName, HsConDeclDetails RdrName)) -> (HappyAbsSyn )-happyIn182 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn182 #-}-happyOut182 :: (HappyAbsSyn ) -> (Located (Located RdrName, HsConDeclDetails RdrName))-happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut182 #-}-happyIn183 :: ([LConDeclField RdrName]) -> (HappyAbsSyn )-happyIn183 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn183 #-}-happyOut183 :: (HappyAbsSyn ) -> ([LConDeclField RdrName])-happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut183 #-}-happyIn184 :: ([LConDeclField RdrName]) -> (HappyAbsSyn )-happyIn184 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn184 #-}-happyOut184 :: (HappyAbsSyn ) -> ([LConDeclField RdrName])-happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut184 #-}-happyIn185 :: (LConDeclField RdrName) -> (HappyAbsSyn )-happyIn185 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn185 #-}-happyOut185 :: (HappyAbsSyn ) -> (LConDeclField RdrName)-happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut185 #-}-happyIn186 :: (HsDeriving RdrName) -> (HappyAbsSyn )-happyIn186 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn186 #-}-happyOut186 :: (HappyAbsSyn ) -> (HsDeriving RdrName)-happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut186 #-}-happyIn187 :: (HsDeriving RdrName) -> (HappyAbsSyn )-happyIn187 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn187 #-}-happyOut187 :: (HappyAbsSyn ) -> (HsDeriving RdrName)-happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut187 #-}-happyIn188 :: (LHsDerivingClause RdrName) -> (HappyAbsSyn )-happyIn188 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn188 #-}-happyOut188 :: (HappyAbsSyn ) -> (LHsDerivingClause RdrName)-happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut188 #-}-happyIn189 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn189 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn189 #-}-happyOut189 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut189 #-}-happyIn190 :: (LDocDecl) -> (HappyAbsSyn )-happyIn190 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn190 #-}-happyOut190 :: (HappyAbsSyn ) -> (LDocDecl)-happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut190 #-}-happyIn191 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn191 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn191 #-}-happyOut191 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut191 #-}-happyIn192 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn192 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn192 #-}-happyOut192 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut192 #-}-happyIn193 :: (Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName))) -> (HappyAbsSyn )-happyIn193 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn193 #-}-happyOut193 :: (HappyAbsSyn ) -> (Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName)))-happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut193 #-}-happyIn194 :: (Located [LGRHS RdrName (LHsExpr RdrName)]) -> (HappyAbsSyn )-happyIn194 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn194 #-}-happyOut194 :: (HappyAbsSyn ) -> (Located [LGRHS RdrName (LHsExpr RdrName)])-happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut194 #-}-happyIn195 :: (LGRHS RdrName (LHsExpr RdrName)) -> (HappyAbsSyn )-happyIn195 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn195 #-}-happyOut195 :: (HappyAbsSyn ) -> (LGRHS RdrName (LHsExpr RdrName))-happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut195 #-}-happyIn196 :: (LHsDecl RdrName) -> (HappyAbsSyn )-happyIn196 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn196 #-}-happyOut196 :: (HappyAbsSyn ) -> (LHsDecl RdrName)-happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut196 #-}-happyIn197 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )-happyIn197 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn197 #-}-happyOut197 :: (HappyAbsSyn ) -> (([AddAnn],Maybe Activation))-happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut197 #-}-happyIn198 :: (([AddAnn],Activation)) -> (HappyAbsSyn )-happyIn198 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn198 #-}-happyOut198 :: (HappyAbsSyn ) -> (([AddAnn],Activation))-happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut198 #-}-happyIn199 :: (Located (HsSplice RdrName)) -> (HappyAbsSyn )-happyIn199 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn199 #-}-happyOut199 :: (HappyAbsSyn ) -> (Located (HsSplice RdrName))-happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut199 #-}-happyIn200 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn200 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn200 #-}-happyOut200 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut200 #-}-happyIn201 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn201 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn201 #-}-happyOut201 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut201 #-}-happyIn202 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn202 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn202 #-}-happyOut202 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut202 #-}-happyIn203 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn203 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn203 #-}-happyOut203 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut203 #-}-happyIn204 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn204 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn204 #-}-happyOut204 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut204 #-}-happyIn205 :: (([Located a],Bool)) -> (HappyAbsSyn )-happyIn205 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn205 #-}-happyOut205 :: (HappyAbsSyn ) -> (([Located a],Bool))-happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut205 #-}-happyIn206 :: (Located (([AddAnn],SourceText),StringLiteral)) -> (HappyAbsSyn )-happyIn206 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn206 #-}-happyOut206 :: (HappyAbsSyn ) -> (Located (([AddAnn],SourceText),StringLiteral))-happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut206 #-}-happyIn207 :: (Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),- ((SourceText,SourceText),(SourceText,SourceText))- )) -> (HappyAbsSyn )-happyIn207 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn207 #-}-happyOut207 :: (HappyAbsSyn ) -> (Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),- ((SourceText,SourceText),(SourceText,SourceText))- ))-happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut207 #-}-happyIn208 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn208 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn208 #-}-happyOut208 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut208 #-}-happyIn209 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn209 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn209 #-}-happyOut209 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut209 #-}-happyIn210 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn210 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn210 #-}-happyOut210 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut210 #-}-happyIn211 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn211 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn211 #-}-happyOut211 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut211 #-}-happyIn212 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn212 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn212 #-}-happyOut212 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut212 #-}-happyIn213 :: ([LHsCmdTop RdrName]) -> (HappyAbsSyn )-happyIn213 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn213 #-}-happyOut213 :: (HappyAbsSyn ) -> ([LHsCmdTop RdrName])-happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut213 #-}-happyIn214 :: (LHsCmdTop RdrName) -> (HappyAbsSyn )-happyIn214 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn214 #-}-happyOut214 :: (HappyAbsSyn ) -> (LHsCmdTop RdrName)-happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut214 #-}-happyIn215 :: (([AddAnn],[LHsDecl RdrName])) -> (HappyAbsSyn )-happyIn215 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn215 #-}-happyOut215 :: (HappyAbsSyn ) -> (([AddAnn],[LHsDecl RdrName]))-happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut215 #-}-happyIn216 :: ([LHsDecl RdrName]) -> (HappyAbsSyn )-happyIn216 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn216 #-}-happyOut216 :: (HappyAbsSyn ) -> ([LHsDecl RdrName])-happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut216 #-}-happyIn217 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn217 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn217 #-}-happyOut217 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut217 #-}-happyIn218 :: (([AddAnn],SumOrTuple)) -> (HappyAbsSyn )-happyIn218 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn218 #-}-happyOut218 :: (HappyAbsSyn ) -> (([AddAnn],SumOrTuple))-happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut218 #-}-happyIn219 :: ((SrcSpan,[LHsTupArg RdrName])) -> (HappyAbsSyn )-happyIn219 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn219 #-}-happyOut219 :: (HappyAbsSyn ) -> ((SrcSpan,[LHsTupArg RdrName]))-happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut219 #-}-happyIn220 :: ([LHsTupArg RdrName]) -> (HappyAbsSyn )-happyIn220 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn220 #-}-happyOut220 :: (HappyAbsSyn ) -> ([LHsTupArg RdrName])-happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut220 #-}-happyIn221 :: (([AddAnn],HsExpr RdrName)) -> (HappyAbsSyn )-happyIn221 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn221 #-}-happyOut221 :: (HappyAbsSyn ) -> (([AddAnn],HsExpr RdrName))-happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut221 #-}-happyIn222 :: (Located [LHsExpr RdrName]) -> (HappyAbsSyn )-happyIn222 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn222 #-}-happyOut222 :: (HappyAbsSyn ) -> (Located [LHsExpr RdrName])-happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut222 #-}-happyIn223 :: (Located [LStmt RdrName (LHsExpr RdrName)]) -> (HappyAbsSyn )-happyIn223 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn223 #-}-happyOut223 :: (HappyAbsSyn ) -> (Located [LStmt RdrName (LHsExpr RdrName)])-happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut223 #-}-happyIn224 :: (Located [[LStmt RdrName (LHsExpr RdrName)]]) -> (HappyAbsSyn )-happyIn224 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn224 #-}-happyOut224 :: (HappyAbsSyn ) -> (Located [[LStmt RdrName (LHsExpr RdrName)]])-happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut224 #-}-happyIn225 :: (Located [LStmt RdrName (LHsExpr RdrName)]) -> (HappyAbsSyn )-happyIn225 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn225 #-}-happyOut225 :: (HappyAbsSyn ) -> (Located [LStmt RdrName (LHsExpr RdrName)])-happyOut225 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut225 #-}-happyIn226 :: (Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)] -> Stmt RdrName (LHsExpr RdrName))) -> (HappyAbsSyn )-happyIn226 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn226 #-}-happyOut226 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)] -> Stmt RdrName (LHsExpr RdrName)))-happyOut226 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut226 #-}-happyIn227 :: (([AddAnn],HsExpr RdrName)) -> (HappyAbsSyn )-happyIn227 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn227 #-}-happyOut227 :: (HappyAbsSyn ) -> (([AddAnn],HsExpr RdrName))-happyOut227 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut227 #-}-happyIn228 :: (Located [LStmt RdrName (LHsExpr RdrName)]) -> (HappyAbsSyn )-happyIn228 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn228 #-}-happyOut228 :: (HappyAbsSyn ) -> (Located [LStmt RdrName (LHsExpr RdrName)])-happyOut228 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut228 #-}-happyIn229 :: (Located [LStmt RdrName (LHsExpr RdrName)]) -> (HappyAbsSyn )-happyIn229 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn229 #-}-happyOut229 :: (HappyAbsSyn ) -> (Located [LStmt RdrName (LHsExpr RdrName)])-happyOut229 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut229 #-}-happyIn230 :: (Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)])) -> (HappyAbsSyn )-happyIn230 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn230 #-}-happyOut230 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]))-happyOut230 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut230 #-}-happyIn231 :: (Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)])) -> (HappyAbsSyn )-happyIn231 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn231 #-}-happyOut231 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]))-happyOut231 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut231 #-}-happyIn232 :: (Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)])) -> (HappyAbsSyn )-happyIn232 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn232 #-}-happyOut232 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]))-happyOut232 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut232 #-}-happyIn233 :: (LMatch RdrName (LHsExpr RdrName)) -> (HappyAbsSyn )-happyIn233 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn233 #-}-happyOut233 :: (HappyAbsSyn ) -> (LMatch RdrName (LHsExpr RdrName))-happyOut233 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut233 #-}-happyIn234 :: (Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName))) -> (HappyAbsSyn )-happyIn234 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn234 #-}-happyOut234 :: (HappyAbsSyn ) -> (Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName)))-happyOut234 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut234 #-}-happyIn235 :: (Located [LGRHS RdrName (LHsExpr RdrName)]) -> (HappyAbsSyn )-happyIn235 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn235 #-}-happyOut235 :: (HappyAbsSyn ) -> (Located [LGRHS RdrName (LHsExpr RdrName)])-happyOut235 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut235 #-}-happyIn236 :: (Located [LGRHS RdrName (LHsExpr RdrName)]) -> (HappyAbsSyn )-happyIn236 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn236 #-}-happyOut236 :: (HappyAbsSyn ) -> (Located [LGRHS RdrName (LHsExpr RdrName)])-happyOut236 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut236 #-}-happyIn237 :: (Located ([AddAnn],[LGRHS RdrName (LHsExpr RdrName)])) -> (HappyAbsSyn )-happyIn237 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn237 #-}-happyOut237 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LGRHS RdrName (LHsExpr RdrName)]))-happyOut237 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut237 #-}-happyIn238 :: (LGRHS RdrName (LHsExpr RdrName)) -> (HappyAbsSyn )-happyIn238 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn238 #-}-happyOut238 :: (HappyAbsSyn ) -> (LGRHS RdrName (LHsExpr RdrName))-happyOut238 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut238 #-}-happyIn239 :: (LPat RdrName) -> (HappyAbsSyn )-happyIn239 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn239 #-}-happyOut239 :: (HappyAbsSyn ) -> (LPat RdrName)-happyOut239 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut239 #-}-happyIn240 :: (LPat RdrName) -> (HappyAbsSyn )-happyIn240 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn240 #-}-happyOut240 :: (HappyAbsSyn ) -> (LPat RdrName)-happyOut240 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut240 #-}-happyIn241 :: (LPat RdrName) -> (HappyAbsSyn )-happyIn241 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn241 #-}-happyOut241 :: (HappyAbsSyn ) -> (LPat RdrName)-happyOut241 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut241 #-}-happyIn242 :: ([LPat RdrName]) -> (HappyAbsSyn )-happyIn242 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn242 #-}-happyOut242 :: (HappyAbsSyn ) -> ([LPat RdrName])-happyOut242 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut242 #-}-happyIn243 :: (Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)])) -> (HappyAbsSyn )-happyIn243 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn243 #-}-happyOut243 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)]))-happyOut243 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut243 #-}-happyIn244 :: (Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)])) -> (HappyAbsSyn )-happyIn244 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn244 #-}-happyOut244 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)]))-happyOut244 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut244 #-}-happyIn245 :: (Maybe (LStmt RdrName (LHsExpr RdrName))) -> (HappyAbsSyn )-happyIn245 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn245 #-}-happyOut245 :: (HappyAbsSyn ) -> (Maybe (LStmt RdrName (LHsExpr RdrName)))-happyOut245 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut245 #-}-happyIn246 :: (LStmt RdrName (LHsExpr RdrName)) -> (HappyAbsSyn )-happyIn246 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn246 #-}-happyOut246 :: (HappyAbsSyn ) -> (LStmt RdrName (LHsExpr RdrName))-happyOut246 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut246 #-}-happyIn247 :: (LStmt RdrName (LHsExpr RdrName)) -> (HappyAbsSyn )-happyIn247 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn247 #-}-happyOut247 :: (HappyAbsSyn ) -> (LStmt RdrName (LHsExpr RdrName))-happyOut247 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut247 #-}-happyIn248 :: (([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool))) -> (HappyAbsSyn )-happyIn248 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn248 #-}-happyOut248 :: (HappyAbsSyn ) -> (([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool)))-happyOut248 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut248 #-}-happyIn249 :: (([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool))) -> (HappyAbsSyn )-happyIn249 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn249 #-}-happyOut249 :: (HappyAbsSyn ) -> (([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool)))-happyOut249 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut249 #-}-happyIn250 :: (LHsRecField RdrName (LHsExpr RdrName)) -> (HappyAbsSyn )-happyIn250 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn250 #-}-happyOut250 :: (HappyAbsSyn ) -> (LHsRecField RdrName (LHsExpr RdrName))-happyOut250 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut250 #-}-happyIn251 :: (Located [LIPBind RdrName]) -> (HappyAbsSyn )-happyIn251 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn251 #-}-happyOut251 :: (HappyAbsSyn ) -> (Located [LIPBind RdrName])-happyOut251 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut251 #-}-happyIn252 :: (LIPBind RdrName) -> (HappyAbsSyn )-happyIn252 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn252 #-}-happyOut252 :: (HappyAbsSyn ) -> (LIPBind RdrName)-happyOut252 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut252 #-}-happyIn253 :: (Located HsIPName) -> (HappyAbsSyn )-happyIn253 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn253 #-}-happyOut253 :: (HappyAbsSyn ) -> (Located HsIPName)-happyOut253 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut253 #-}-happyIn254 :: (Located FastString) -> (HappyAbsSyn )-happyIn254 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn254 #-}-happyOut254 :: (HappyAbsSyn ) -> (Located FastString)-happyOut254 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut254 #-}-happyIn255 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn255 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn255 #-}-happyOut255 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))-happyOut255 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut255 #-}-happyIn256 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn256 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn256 #-}-happyOut256 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))-happyOut256 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut256 #-}-happyIn257 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn257 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn257 #-}-happyOut257 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))-happyOut257 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut257 #-}-happyIn258 :: ([LBooleanFormula (Located RdrName)]) -> (HappyAbsSyn )-happyIn258 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn258 #-}-happyOut258 :: (HappyAbsSyn ) -> ([LBooleanFormula (Located RdrName)])-happyOut258 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut258 #-}-happyIn259 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn259 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn259 #-}-happyOut259 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))-happyOut259 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut259 #-}-happyIn260 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn260 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn260 #-}-happyOut260 :: (HappyAbsSyn ) -> (Located [Located RdrName])-happyOut260 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut260 #-}-happyIn261 :: (Located RdrName) -> (HappyAbsSyn )-happyIn261 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn261 #-}-happyOut261 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut261 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut261 #-}-happyIn262 :: (Located RdrName) -> (HappyAbsSyn )-happyIn262 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn262 #-}-happyOut262 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut262 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut262 #-}-happyIn263 :: (Located RdrName) -> (HappyAbsSyn )-happyIn263 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn263 #-}-happyOut263 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut263 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut263 #-}-happyIn264 :: (Located RdrName) -> (HappyAbsSyn )-happyIn264 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn264 #-}-happyOut264 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut264 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut264 #-}-happyIn265 :: (Located RdrName) -> (HappyAbsSyn )-happyIn265 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn265 #-}-happyOut265 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut265 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut265 #-}-happyIn266 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn266 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn266 #-}-happyOut266 :: (HappyAbsSyn ) -> (Located [Located RdrName])-happyOut266 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut266 #-}-happyIn267 :: (Located DataCon) -> (HappyAbsSyn )-happyIn267 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn267 #-}-happyOut267 :: (HappyAbsSyn ) -> (Located DataCon)-happyOut267 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut267 #-}-happyIn268 :: (Located DataCon) -> (HappyAbsSyn )-happyIn268 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn268 #-}-happyOut268 :: (HappyAbsSyn ) -> (Located DataCon)-happyOut268 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut268 #-}-happyIn269 :: (Located RdrName) -> (HappyAbsSyn )-happyIn269 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn269 #-}-happyOut269 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut269 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut269 #-}-happyIn270 :: (Located RdrName) -> (HappyAbsSyn )-happyIn270 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn270 #-}-happyOut270 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut270 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut270 #-}-happyIn271 :: (Located RdrName) -> (HappyAbsSyn )-happyIn271 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn271 #-}-happyOut271 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut271 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut271 #-}-happyIn272 :: (Located RdrName) -> (HappyAbsSyn )-happyIn272 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn272 #-}-happyOut272 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut272 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut272 #-}-happyIn273 :: (Located RdrName) -> (HappyAbsSyn )-happyIn273 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn273 #-}-happyOut273 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut273 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut273 #-}-happyIn274 :: (Located RdrName) -> (HappyAbsSyn )-happyIn274 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn274 #-}-happyOut274 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut274 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut274 #-}-happyIn275 :: (Located RdrName) -> (HappyAbsSyn )-happyIn275 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn275 #-}-happyOut275 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut275 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut275 #-}-happyIn276 :: (Located RdrName) -> (HappyAbsSyn )-happyIn276 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn276 #-}-happyOut276 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut276 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut276 #-}-happyIn277 :: (LHsType RdrName) -> (HappyAbsSyn )-happyIn277 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn277 #-}-happyOut277 :: (HappyAbsSyn ) -> (LHsType RdrName)-happyOut277 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut277 #-}-happyIn278 :: (Located RdrName) -> (HappyAbsSyn )-happyIn278 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn278 #-}-happyOut278 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut278 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut278 #-}-happyIn279 :: (Located RdrName) -> (HappyAbsSyn )-happyIn279 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn279 #-}-happyOut279 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut279 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut279 #-}-happyIn280 :: (Located RdrName) -> (HappyAbsSyn )-happyIn280 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn280 #-}-happyOut280 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut280 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut280 #-}-happyIn281 :: (Located RdrName) -> (HappyAbsSyn )-happyIn281 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn281 #-}-happyOut281 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut281 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut281 #-}-happyIn282 :: (Located RdrName) -> (HappyAbsSyn )-happyIn282 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn282 #-}-happyOut282 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut282 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut282 #-}-happyIn283 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn283 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn283 #-}-happyOut283 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut283 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut283 #-}-happyIn284 :: (LHsExpr RdrName) -> (HappyAbsSyn )-happyIn284 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn284 #-}-happyOut284 :: (HappyAbsSyn ) -> (LHsExpr RdrName)-happyOut284 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut284 #-}-happyIn285 :: (Located RdrName) -> (HappyAbsSyn )-happyIn285 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn285 #-}-happyOut285 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut285 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut285 #-}-happyIn286 :: (Located RdrName) -> (HappyAbsSyn )-happyIn286 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn286 #-}-happyOut286 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut286 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut286 #-}-happyIn287 :: (Located RdrName) -> (HappyAbsSyn )-happyIn287 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn287 #-}-happyOut287 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut287 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut287 #-}-happyIn288 :: (Located RdrName) -> (HappyAbsSyn )-happyIn288 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn288 #-}-happyOut288 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut288 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut288 #-}-happyIn289 :: (Located RdrName) -> (HappyAbsSyn )-happyIn289 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn289 #-}-happyOut289 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut289 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut289 #-}-happyIn290 :: (Located RdrName) -> (HappyAbsSyn )-happyIn290 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn290 #-}-happyOut290 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut290 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut290 #-}-happyIn291 :: (Located RdrName) -> (HappyAbsSyn )-happyIn291 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn291 #-}-happyOut291 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut291 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut291 #-}-happyIn292 :: (Located RdrName) -> (HappyAbsSyn )-happyIn292 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn292 #-}-happyOut292 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut292 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut292 #-}-happyIn293 :: (Located RdrName) -> (HappyAbsSyn )-happyIn293 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn293 #-}-happyOut293 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut293 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut293 #-}-happyIn294 :: (Located RdrName) -> (HappyAbsSyn )-happyIn294 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn294 #-}-happyOut294 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut294 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut294 #-}-happyIn295 :: (Located RdrName) -> (HappyAbsSyn )-happyIn295 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn295 #-}-happyOut295 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut295 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut295 #-}-happyIn296 :: (Located RdrName) -> (HappyAbsSyn )-happyIn296 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn296 #-}-happyOut296 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut296 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut296 #-}-happyIn297 :: (Located RdrName) -> (HappyAbsSyn )-happyIn297 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn297 #-}-happyOut297 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut297 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut297 #-}-happyIn298 :: (Located RdrName) -> (HappyAbsSyn )-happyIn298 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn298 #-}-happyOut298 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut298 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut298 #-}-happyIn299 :: (Located FastString) -> (HappyAbsSyn )-happyIn299 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn299 #-}-happyOut299 :: (HappyAbsSyn ) -> (Located FastString)-happyOut299 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut299 #-}-happyIn300 :: (Located FastString) -> (HappyAbsSyn )-happyIn300 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn300 #-}-happyOut300 :: (HappyAbsSyn ) -> (Located FastString)-happyOut300 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut300 #-}-happyIn301 :: (Located RdrName) -> (HappyAbsSyn )-happyIn301 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn301 #-}-happyOut301 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut301 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut301 #-}-happyIn302 :: (Located RdrName) -> (HappyAbsSyn )-happyIn302 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn302 #-}-happyOut302 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut302 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut302 #-}-happyIn303 :: (Located RdrName) -> (HappyAbsSyn )-happyIn303 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn303 #-}-happyOut303 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut303 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut303 #-}-happyIn304 :: (Located RdrName) -> (HappyAbsSyn )-happyIn304 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn304 #-}-happyOut304 :: (HappyAbsSyn ) -> (Located RdrName)-happyOut304 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut304 #-}-happyIn305 :: (Located HsLit) -> (HappyAbsSyn )-happyIn305 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn305 #-}-happyOut305 :: (HappyAbsSyn ) -> (Located HsLit)-happyOut305 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut305 #-}-happyIn306 :: (()) -> (HappyAbsSyn )-happyIn306 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn306 #-}-happyOut306 :: (HappyAbsSyn ) -> (())-happyOut306 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut306 #-}-happyIn307 :: (Located ModuleName) -> (HappyAbsSyn )-happyIn307 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn307 #-}-happyOut307 :: (HappyAbsSyn ) -> (Located ModuleName)-happyOut307 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut307 #-}-happyIn308 :: (([SrcSpan],Int)) -> (HappyAbsSyn )-happyIn308 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn308 #-}-happyOut308 :: (HappyAbsSyn ) -> (([SrcSpan],Int))-happyOut308 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut308 #-}-happyIn309 :: (([SrcSpan],Int)) -> (HappyAbsSyn )-happyIn309 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn309 #-}-happyOut309 :: (HappyAbsSyn ) -> (([SrcSpan],Int))-happyOut309 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut309 #-}-happyIn310 :: (([SrcSpan],Int)) -> (HappyAbsSyn )-happyIn310 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn310 #-}-happyOut310 :: (HappyAbsSyn ) -> (([SrcSpan],Int))-happyOut310 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut310 #-}-happyIn311 :: (LHsDocString) -> (HappyAbsSyn )-happyIn311 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn311 #-}-happyOut311 :: (HappyAbsSyn ) -> (LHsDocString)-happyOut311 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut311 #-}-happyIn312 :: (LHsDocString) -> (HappyAbsSyn )-happyIn312 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn312 #-}-happyOut312 :: (HappyAbsSyn ) -> (LHsDocString)-happyOut312 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut312 #-}-happyIn313 :: (Located (String, HsDocString)) -> (HappyAbsSyn )-happyIn313 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn313 #-}-happyOut313 :: (HappyAbsSyn ) -> (Located (String, HsDocString))-happyOut313 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut313 #-}-happyIn314 :: (Located (Int, HsDocString)) -> (HappyAbsSyn )-happyIn314 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn314 #-}-happyOut314 :: (HappyAbsSyn ) -> (Located (Int, HsDocString))-happyOut314 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut314 #-}-happyIn315 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn315 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn315 #-}-happyOut315 :: (HappyAbsSyn ) -> (Maybe LHsDocString)-happyOut315 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut315 #-}-happyIn316 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn316 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn316 #-}-happyOut316 :: (HappyAbsSyn ) -> (Maybe LHsDocString)-happyOut316 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut316 #-}-happyIn317 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn317 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn317 #-}-happyOut317 :: (HappyAbsSyn ) -> (Maybe LHsDocString)-happyOut317 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut317 #-}-happyInTok :: ((Located Token)) -> (HappyAbsSyn )-happyInTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn ) -> ((Located Token))-happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOutTok #-}---happyExpList :: HappyAddr-happyExpList = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\xff\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xdf\x7c\xd5\xff\x7f\xf9\xdf\xcf\x07\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x5c\x44\xff\x7f\xf9\x9f\x03\x04\x41\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\xff\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x08\x80\x21\x88\x82\xfe\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x21\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x80\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xb8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xe8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\xb4\xa1\xa8\xc3\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\xc6\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x08\x80\x21\x88\x82\x5e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x84\x21\x00\x41\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x40\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x91\x80\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x80\x10\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xf1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xb8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x91\x21\xa8\xcb\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x91\x21\xa8\xce\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\xa8\x02\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x88\x02\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\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x91\x21\xa8\xcb\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x20\x04\xbf\x3f\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x40\x40\x80\x54\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x40\x41\x00\x54\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x80\x21\x00\x41\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x80\x00\x40\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x80\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x41\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x02\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x80\x3f\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\xca\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x91\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xf1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x08\x80\x21\x88\x43\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\x00\x00\x02\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x5c\x44\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x5c\x44\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x80\x21\x00\x80\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\xb4\x00\x00\x41\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x80\x21\x00\x80\x98\x01\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x80\x21\x00\x41\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\xca\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x40\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\xff\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\xff\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x04\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\xc3\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x07\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x06\x10\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x21\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa9\x2a\x67\xfe\x1f\x5e\x7f\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\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xac\x2a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x4c\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x4c\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\xca\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\xa8\x1a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xdf\x7c\xd5\xff\x7f\xf9\xdf\xcf\x07\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x40\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\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\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x90\x00\x00\x00\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xdf\x7c\xd5\xff\x7f\xf9\xdf\xcf\x07\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x04\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x5c\x44\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x80\x21\x00\x80\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x2a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\xff\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x04\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x07\x3e\xe1\x03\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x4c\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x4c\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd6\x5c\x54\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd6\x5c\x54\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd2\x5c\x55\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd2\x5c\x55\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x5c\x44\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x5c\x44\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x20\x04\xbf\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x04\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x04\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x04\x07\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x06\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x80\x54\xbf\x3f\xe9\x03\x00\x00\x00\x00\x00\x80\x40\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x90\x21\x00\x00\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x04\x07\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x06\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x83\xdf\x31\x00\x00\x63\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd6\x5c\x54\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd2\x5c\x55\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x0c\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x0c\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\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\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x04\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x10\x81\xa8\x82\x57\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x41\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x54\xbf\x3f\xe1\x03\x00\x00\x04\x00\x00\x80\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\xb4\xa1\xa8\xc3\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x3f\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x10\x81\xa8\x82\x57\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x04\x07\x3e\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x0e\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x54\xbf\x3f\xe1\x03\x00\x00\x04\x00\x00\x80\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x80\x54\xbf\x3f\xe9\x03\x00\x00\x00\x00\x00\x80\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--{-# NOINLINE happyExpListPerState #-}-happyExpListPerState st =- token_strs_expected- where token_strs = ["error","%dummy","%start_parseModule","%start_parseSignature","%start_parseImport","%start_parseStatement","%start_parseDeclaration","%start_parseExpression","%start_parsePattern","%start_parseTypeSignature","%start_parseStmt","%start_parseIdentifier","%start_parseType","%start_parseBackpack","%start_parseHeader","identifier","backpack","units","unit","unitid","msubsts","msubst","moduleid","pkgname","litpkgname_segment","litpkgname","mayberns","rns","rn","unitbody","unitdecls","unitdecl","signature","module","maybedocheader","missing_module_keyword","implicit_top","maybemodwarning","body","body2","top","top1","header","header_body","header_body2","header_top","header_top_importdecls","maybeexports","exportlist","exportlist1","expdoclist","exp_doc","export","export_subspec","qcnames","qcnames1","qcname_ext_w_wildcard","qcname_ext","qcname","semis1","semis","importdecls","importdecls_semi","importdecl","maybe_src","maybe_safe","maybe_pkg","optqualified","maybeas","maybeimpspec","impspec","prec","infix","ops","topdecls","topdecls_semi","topdecl","cl_decl","ty_decl","inst_decl","overlap_pragma","deriv_strategy","opt_injective_info","injectivity_cond","inj_varids","where_type_family","ty_fam_inst_eqn_list","ty_fam_inst_eqns","ty_fam_inst_eqn","at_decl_cls","opt_family","at_decl_inst","data_or_newtype","opt_kind_sig","opt_datafam_kind_sig","opt_tyfam_kind_sig","opt_at_kind_inj_sig","tycl_hdr","capi_ctype","stand_alone_deriving","role_annot","maybe_roles","roles","role","pattern_synonym_decl","pattern_synonym_lhs","vars0","cvars1","where_decls","pattern_synonym_sig","decl_cls","decls_cls","decllist_cls","where_cls","decl_inst","decls_inst","decllist_inst","where_inst","decls","decllist","binds","wherebinds","rules","rule","rule_activation","rule_explicit_activation","rule_forall","rule_var_list","rule_var","warnings","warning","deprecations","deprecation","strings","stringlist","annotation","fdecl","callconv","safety","fspec","opt_sig","opt_asig","opt_tyconsig","sigtype","sigtypedoc","sig_vars","sigtypes1","strict_mark","strictness","unpackedness","ctype","ctypedoc","context","context_no_ops","type","typedoc","btype","btype_no_ops","tyapps","tyapp","atype","inst_type","deriv_types","comma_types0","comma_types1","bar_types2","tv_bndrs","tv_bndr","fds","fds1","fd","varids0","kind","gadt_constrlist","gadt_constrs","gadt_constr_with_doc","gadt_constr","constrs","constrs1","constr","forall","constr_stuff","fielddecls","fielddecls1","fielddecl","maybe_derivings","derivings","deriving","docdecl","docdecld","decl_no_th","decl","rhs","gdrhs","gdrh","sigdecl","activation","explicit_activation","quasiquote","exp","infixexp","infixexp_top","exp10_top","exp10","optSemi","scc_annot","hpc_annot","fexp","aexp","aexp1","aexp2","splice_exp","cmdargs","acmd","cvtopbody","cvtopdecls0","texp","tup_exprs","commas_tup_tail","tup_tail","list","lexps","flattenedpquals","pquals","squals","transformqual","parr","guardquals","guardquals1","altslist","alts","alts1","alt","alt_rhs","ralt","gdpats","ifgdpats","gdpat","pat","bindpat","apat","apats","stmtlist","stmts","maybe_stmt","stmt","qual","fbinds","fbinds1","fbind","dbinds","dbind","ipvar","overloaded_label","name_boolformula_opt","name_boolformula","name_boolformula_and","name_boolformula_and_list","name_boolformula_atom","namelist","name_var","qcon_nowiredlist","qcon","gen_qcon","con","con_list","sysdcon_nolist","sysdcon","conop","qconop","gtycon","ntgtycon","oqtycon","oqtycon_no_varcon","qtyconop","qtycon","qtycondoc","tycon","qtyconsym","tyconsym","op","varop","qop","qopm","qvarop","qvaropm","tyvar","tyvarop","tyvarid","var","qvar","qvarid","varid","qvarsym","qvarsym_no_minus","qvarsym1","varsym","varsym_no_minus","special_id","special_sym","qconid","conid","qconsym","consym","literal","close","modid","commas","bars0","bars","docnext","docprev","docnamed","docsection","moduleheader","maybe_docprev","maybe_docnext","'_'","'as'","'case'","'class'","'data'","'default'","'deriving'","'do'","'else'","'hiding'","'if'","'import'","'in'","'infix'","'infixl'","'infixr'","'instance'","'let'","'module'","'newtype'","'of'","'qualified'","'then'","'type'","'where'","'forall'","'foreign'","'export'","'label'","'dynamic'","'safe'","'interruptible'","'unsafe'","'mdo'","'family'","'role'","'stdcall'","'ccall'","'capi'","'prim'","'javascript'","'proc'","'rec'","'group'","'by'","'using'","'pattern'","'static'","'stock'","'anyclass'","'unit'","'signature'","'dependency'","'{-# INLINE'","'{-# SPECIALISE'","'{-# SPECIALISE_INLINE'","'{-# SOURCE'","'{-# RULES'","'{-# CORE'","'{-# SCC'","'{-# GENERATED'","'{-# DEPRECATED'","'{-# WARNING'","'{-# UNPACK'","'{-# NOUNPACK'","'{-# ANN'","'{-# VECTORISE'","'{-# VECTORISE_SCALAR'","'{-# NOVECTORISE'","'{-# MINIMAL'","'{-# CTYPE'","'{-# OVERLAPPING'","'{-# OVERLAPPABLE'","'{-# OVERLAPS'","'{-# INCOHERENT'","'{-# COMPLETE'","'#-}'","'..'","':'","'::'","'='","'\\\\'","'lcase'","'|'","'<-'","'->'","'@'","'~'","'~#'","'=>'","'-'","'!'","'-<'","'>-'","'-<<'","'>>-'","'.'","TYPEAPP","'{'","'}'","vocurly","vccurly","'['","']'","'[:'","':]'","'('","')'","'(#'","'#)'","'(|'","'|)'","';'","','","'`'","SIMPLEQUOTE","VARID","CONID","VARSYM","CONSYM","QVARID","QCONID","QVARSYM","QCONSYM","IPDUPVARID","LABELVARID","CHAR","STRING","INTEGER","RATIONAL","PRIMCHAR","PRIMSTRING","PRIMINTEGER","PRIMWORD","PRIMFLOAT","PRIMDOUBLE","DOCNEXT","DOCPREV","DOCNAMED","DOCSECTION","'[|'","'[p|'","'[t|'","'[d|'","'|]'","'[||'","'||]'","TH_ID_SPLICE","'$('","TH_ID_TY_SPLICE","'$$('","TH_TY_QUOTE","TH_QUASIQUOTE","TH_QQUASIQUOTE","%eof"]- bit_start = st * 472- bit_end = (st + 1) * 472- read_bit = readArrayBit happyExpList- bits = map read_bit [bit_start..bit_end - 1]- bits_indexed = zip bits [0..471]- token_strs_expected = concatMap f bits_indexed- f (False, _) = []- f (True, nr) = [token_strs !! nr]--happyActOffsets :: HappyAddr-happyActOffsets = HappyA# "\x30\x00\x0e\x01\x7a\x00\xd7\x17\x9d\x0d\x98\x1f\x96\x1c\x3b\x14\xd7\x17\xa6\x3e\xc6\x29\x3a\x00\x44\x01\xae\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x02\x00\x00\x00\x00\x17\x01\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x01\xb5\x01\xb5\x01\xe0\x36\x00\x00\xdf\x00\x6f\x01\xc6\x01\x00\x00\xce\x02\x5d\x35\x00\x00\x00\x00\x00\x00\x1c\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\xc8\x45\x00\x00\x00\x00\x00\x00\xdc\x01\x79\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x43\x28\xc4\x28\xc0\x26\x41\x27\x10\x42\x0d\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x02\x0b\x0b\x71\x01\x0d\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x02\x20\x11\x00\x00\x00\x00\x98\x1f\x98\x1f\x78\x22\x00\x00\xdc\x02\x00\x00\x00\x00\x3e\x03\x0e\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x03\x00\x00\x00\x00\x98\x1f\x21\x04\x71\x18\xb4\x04\x0f\x05\x9c\x24\x0f\x05\x9c\x24\x44\x03\xf5\x01\x49\x03\xef\x21\x9c\x24\x01\x23\x9c\x24\xd5\x14\xa3\x16\x39\x11\xd3\x11\x37\x26\x25\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x1f\x98\x1f\xc6\x29\x3b\x05\x98\x1f\x00\x00\x98\x1f\x00\x00\x98\x1f\x2d\x41\x64\x03\x00\x00\x5c\x03\x40\x0c\x00\x00\x6a\x03\xa9\x03\x00\x00\x00\x00\x00\x00\x42\x05\xe7\x03\xc4\x03\x88\x00\xc4\x03\xae\x42\x72\x43\xe7\x03\x6d\x12\x00\x00\x9a\x03\x9c\x24\x9a\x03\x9a\x03\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x05\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x35\x19\x04\xe6\x03\x63\x01\xac\x05\x00\x00\x45\x29\x9a\x01\xd0\x43\xbe\x03\xf0\x43\xf0\x43\x52\x43\x30\x42\x42\x04\xae\x42\x9c\x24\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x03\xd8\x03\x46\x04\x00\x04\x79\x04\x18\x04\xa3\x04\x00\x00\x00\x00\x00\x00\x59\x04\x73\x04\x62\x00\xfc\x02\xfc\x02\x0e\x05\x86\x04\xda\x04\xac\x04\xcd\x03\xd3\x04\xcd\x03\xcd\x03\x9c\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x24\xbb\x04\xef\x02\x40\x00\x00\x00\xa6\x01\xc6\x04\x62\x01\x00\x00\xa6\x01\x78\x01\x00\x00\xd4\x04\x1a\x02\xcc\x44\x13\x05\x3f\x00\x50\x02\x00\x00\xf9\x05\xf9\x05\x20\x05\x22\x05\x5d\x35\x5d\x35\xcc\x02\xc6\x29\x3a\x05\x3d\x05\x4c\x05\x57\x05\x8c\x05\x00\x00\x00\x00\x00\x00\xc6\x29\x5d\x35\x60\x05\x5e\x05\x00\x00\xda\x04\x00\x00\x66\x21\x00\x00\x47\x2a\x74\x3f\x5d\x35\x75\x05\x43\x05\x00\x00\x78\x05\x20\x11\x87\x01\x6c\x05\x00\x00\x98\x1f\x00\x00\x00\x00\x81\x05\x90\x05\x9a\x05\x9d\x05\x07\x13\x6f\x15\x00\x00\x01\x23\x00\x00\x00\x00\x8f\x41\xb1\x05\xd6\x05\xe7\x05\x00\x00\xe4\x05\x00\x00\xd4\x05\x00\x00\xec\x42\x38\x00\xae\x42\x00\x00\x47\x01\xae\x42\xc8\x2a\xae\x42\x00\x00\x32\x06\x9f\x10\x9f\x10\x14\x45\x49\x2b\xfb\x01\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x05\xed\x05\xd8\x08\x3a\x03\xfd\x05\x00\x06\xdc\x05\xea\x05\x00\x00\x00\x00\xf0\x05\xe2\x06\xf4\x05\x00\x00\x00\x00\x3d\x04\x00\x00\x00\x00\x14\x02\x1a\x06\x00\x00\x00\x00\xa1\x13\x00\x00\x21\x06\x99\x01\x28\x06\x37\x06\xcd\x01\x3a\x06\x31\x06\x00\x00\x00\x00\x8a\x23\x00\x00\x00\x00\x13\x24\x48\x05\x9c\x24\x23\x06\x58\x06\x5b\x06\x62\x06\x00\x00\x00\x00\x0b\x19\x0b\x19\x5d\x06\x00\x00\xa7\x06\x45\x06\x59\x01\x00\x00\x00\x00\x30\x1d\x63\x06\x00\x00\xa3\x06\x9c\x24\x98\x1f\x8e\x42\x00\x00\xe0\x36\x00\x00\x00\x00\x98\x1f\xca\x2b\x98\x1f\x98\x1f\x98\x1f\x98\x1f\x4b\x06\x4c\x06\x6f\x03\x54\x06\x55\x06\x15\x02\x56\x06\x57\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x2b\xc2\x27\xaf\x41\x51\x06\x59\x06\xa1\x01\x5a\x06\x64\x06\x86\x03\x00\x00\xbc\x01\x6a\x06\x57\x02\x6b\x06\x6c\x06\x6d\x06\x00\x00\x5f\x06\x00\x00\x77\x02\x00\x00\x76\x06\x00\x00\xb2\x01\x00\x00\x14\x45\x00\x00\x00\x00\x7a\x06\xc8\x45\x00\x00\x54\x46\x5d\x35\x00\x00\xca\x2b\xca\x2b\x00\x00\x00\x00\xab\x40\x92\x00\x00\x00\x13\x3e\x58\x00\x00\x00\x6e\x06\x00\x00\xa6\x03\xa6\x03\x26\x04\x00\x00\x00\x00\x26\x04\x00\x00\x00\x00\xd4\x06\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x06\xce\x06\x8e\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x06\x00\x00\xca\x2b\xd4\x00\x00\x00\xc2\x02\x7c\x06\x00\x00\x00\x00\xca\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x2b\x00\x00\xca\x2b\x00\x00\x00\x00\x00\x00\xca\x2b\xca\x2b\x00\x00\x00\x00\x7e\x06\x7d\x06\x86\x06\x87\x06\x88\x06\x89\x06\x93\x06\x94\x06\x95\x06\x97\x06\x92\x06\x9f\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\x96\x06\x00\x00\x98\x06\xba\x06\x00\x00\x00\x00\x00\x00\x48\x05\x8c\x01\xb6\x06\xa1\x06\x00\x00\x00\x00\x00\x00\xfd\x06\x00\x00\x98\x1f\x98\x1f\x5d\x00\x00\x00\xff\x00\x98\x1f\x00\x00\x00\x00\xc6\x06\x00\x00\x00\x00\x3d\x17\xc5\x0b\x13\x24\xc7\x06\xa3\x16\x00\x00\x98\x1f\xa5\x19\xa3\x16\x00\x00\x98\x1f\xa5\x19\xa3\x16\x00\x00\xa4\x06\x00\x00\x00\x00\x00\x00\x09\x16\xc9\x06\x00\x00\x25\x25\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x0d\x62\x00\xb7\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x06\xb3\x06\x00\x00\xbd\x06\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x43\x00\x00\x00\x00\xca\x06\x00\x00\x7f\x01\xd0\x06\xc8\x45\x40\x01\x69\x00\x00\x00\x00\x00\x15\x0e\x2e\x1a\x6b\x00\x00\x00\xdf\x06\x38\x01\xcf\x01\xd8\x06\x00\x00\xe5\x06\xe4\x06\xb8\x06\xd2\x06\xe8\x06\x00\x00\xf2\x06\xd5\x06\xdb\x06\x4e\x44\x4e\x44\x00\x00\xf3\x06\xcd\x03\xe7\x03\xd1\x06\xf4\x06\x00\x00\xd9\x06\x49\x0f\x00\x00\x00\x00\x98\x1f\xa3\x16\x39\x01\x5d\x35\x21\x00\xda\x06\x00\x00\xf5\x06\x3b\x00\xfe\x06\xc8\x45\x00\x00\x00\x00\x5b\x00\x00\x00\x98\x1f\x30\x1d\x5d\x35\x37\x07\x00\x00\x07\x07\xef\x06\xac\x05\x00\x00\x00\x00\x00\x00\x00\x00\x43\x07\x55\x00\x42\x03\x15\x01\x00\x00\x0e\x07\x4b\x2c\x59\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x3d\xdb\x25\xee\x06\x4b\x2c\x00\x00\xdb\x25\xdb\x25\xca\x1d\xca\x1d\x4b\x07\x00\x00\x4a\x01\x00\x00\xe6\x06\x00\x00\xe7\x06\x00\x00\x00\x00\x6e\x44\x6e\x44\x00\x00\x00\x00\x6e\x44\xae\x25\x1d\x07\x20\x07\xd6\x03\x21\x07\x98\x1f\x1f\x04\x00\x00\x00\x00\x00\x00\x5a\x07\x00\x00\xa0\x04\xa0\x04\x00\x00\x00\x00\x00\x00\x66\x07\x00\x00\x03\x07\x00\x00\x9d\x0d\x17\x07\xa6\x01\xa6\x01\x17\x07\xf9\x06\x00\x00\x00\x00\xcd\x03\x39\x07\x00\x00\x00\x00\xcd\x03\x00\x00\x00\x00\x3c\x07\x00\x00\x00\x00\x00\x00\x08\x03\x00\x00\x00\x00\x2f\x00\x22\x07\x98\x1f\x40\x45\x72\x07\x00\x00\x30\x07\x23\x07\x00\x00\x00\x00\x25\x07\x00\x00\xb7\x3d\x00\x00\x46\x07\x4c\x07\x4f\x07\x52\x07\x6e\x45\x00\x00\x00\x00\xcc\x2c\x47\x07\xcc\x2c\xc8\x45\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x05\xcc\x2c\x00\x00\x00\x00\xcc\x2c\x34\x07\x00\x00\xf4\x45\x00\x00\x56\x05\x00\x00\x56\x07\x8f\x07\x00\x00\x00\x00\x61\x05\x48\x07\x5d\x35\x55\x07\x4d\x2d\x4d\x2d\x00\x00\x91\x07\xa8\x07\x63\x07\xce\x2d\x21\x00\x00\x00\x70\x07\x00\x00\x00\x00\x6a\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x2d\x00\x00\x57\x07\xce\x2d\x00\x00\x00\x00\x00\x00\x44\x07\x00\x00\x9f\x10\x98\x1f\x00\x00\x00\x00\x4f\x2e\x6e\x45\x62\x07\x5d\x35\x4f\x2e\x4f\x2e\xfb\x01\x00\x00\x00\x00\x5e\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x03\x00\x00\x00\x00\x00\x00\x20\x02\x00\x00\x00\x00\x32\x20\x00\x00\x38\x03\x00\x00\x00\x00\x00\x00\x75\x07\xe0\x36\x00\x00\x62\x00\x5f\x07\x00\x00\x76\x07\x00\x00\xc8\x1a\x74\x07\x00\x00\x50\x07\x00\x00\x00\x00\x62\x1b\x00\x00\x00\x00\x00\x00\xcc\x20\x64\x1e\xcc\x20\x00\x00\x00\x00\xa3\x16\x8e\x42\x00\x00\x00\x00\x00\x00\xd0\x2e\x00\x00\x00\x00\x85\x07\x00\x00\x6e\x07\x00\x00\x6f\x07\x7b\x07\x53\x07\xd0\x2e\x00\x00\xd0\x2e\x55\x0d\x76\x05\x00\x00\x71\x07\x71\x07\xcb\x07\x1a\x04\xcc\x07\x00\x00\x32\x00\x32\x00\x00\x00\x7a\x07\x5d\x07\x00\x00\x60\x07\x00\x00\x00\x00\x00\x00\x80\x07\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x07\x00\x00\x94\x07\x00\x00\x00\x00\xe4\x02\xfe\x1e\x00\x00\x00\x00\xcc\x20\xcc\x20\xc3\x07\xb4\x02\xfc\x1b\xfc\x1b\xcc\x20\x88\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x07\x8d\x07\xb5\x07\x00\x00\xb7\x07\x00\x00\xec\x07\xff\x07\x00\x00\x7e\x07\x00\x00\x01\x08\x00\x00\x22\x02\x01\x08\xb2\x05\x51\x2f\xe1\x04\xd2\x2f\x00\x00\x00\x00\xcc\x20\x00\x00\x37\x0e\x37\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x0e\xd1\x0e\x00\x00\x00\x00\x00\x00\xf0\x07\x54\x46\x00\x00\xbc\x07\x53\x30\x00\x00\x00\x00\xdb\x25\x00\x00\x00\x00\xc4\x05\xac\x07\x9a\x45\x00\x00\xdb\x25\xb1\x11\x00\x00\x00\x00\xab\x07\x00\x00\x96\x07\x00\x00\xc7\x07\x00\x00\xd1\x07\x0f\x04\x00\x00\x07\x08\xd4\x07\xd5\x07\x0a\x08\xa7\x07\x00\x00\x0d\x06\x00\x00\x00\x00\x0d\x06\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x20\xd9\x07\x00\x00\x00\x00\x9f\x10\x9f\x10\x00\x00\x00\x00\x53\x30\x00\x00\xd6\x07\x00\x00\x10\x06\x00\x00\xe3\x07\x00\x00\xa1\x00\x00\x00\x00\x00\x5d\x35\xd8\x01\x00\x00\x54\x46\x00\x00\x00\x00\x27\x01\x00\x00\x08\x08\xcc\x20\xd4\x30\xe4\x01\x00\x00\x00\x00\x00\x00\x84\x03\x84\x03\x00\x00\x11\x03\x00\x00\xa3\x00\x00\x00\x13\x08\x00\x00\x28\x08\x00\x00\x00\x00\x55\x31\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x20\xcc\x20\xcc\x20\x00\x00\x00\x00\x00\x00\x00\x00\x19\x08\xdf\x07\xcc\x20\xb8\x07\x2f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x00\x00\x8a\x01\x41\x3e\x4a\x02\x11\x06\xcf\x07\x00\x00\xa0\x3f\x1a\x04\x00\x00\x00\x00\x00\x00\x11\x06\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x04\xd2\x07\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x04\x3b\x03\xd0\x03\x4f\x03\x1a\x04\x00\x00\x00\x00\x00\x00\x42\x00\xdd\x07\xd8\x07\x6f\x3e\x0f\x04\x0f\x04\x00\x00\xcc\x20\xfb\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x08\x00\x00\x00\x00\xe0\x36\x28\x46\xf8\x07\xc4\x07\x00\x00\xda\x33\x62\x00\xe4\x07\x00\x00\x04\x08\xe6\x07\xf5\x07\x00\x00\x6b\x0f\x00\x00\xc1\x03\x5d\x35\x5d\x35\xaf\x0e\x5d\x35\x00\x00\x00\x00\x00\x00\x05\x10\x00\x00\x00\x00\x5d\x35\x00\x00\x5b\x34\xdc\x34\x54\x46\x00\x00\x89\x01\x7c\x02\x55\x31\x00\x00\x52\x00\x0f\x04\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\xf7\x07\x00\x00\x00\x00\x00\x00\xf4\x07\x1a\x04\xf6\x07\x00\x00\x00\x00\x54\x46\x00\x00\x9e\x01\x00\x00\x62\x00\xa3\x02\xfc\x07\x21\x00\x00\x00\x11\x08\xd6\x31\x99\x04\x00\x00\x00\x00\x57\x32\xd8\x32\x00\x00\x00\x00\xe7\x03\x59\x33\x84\x03\x00\x00\xf1\x07\x14\x00\xf9\x07\x00\x00\x00\x00\xda\x07\x06\x08\x10\x08\xde\x35\x00\x00\xe1\x07\xcc\x20\xeb\x07\x00\x00\x45\x01\x45\x01\x00\x00\x0f\x04\x00\x00\x0f\x04\x00\x00\x00\x00\x0b\x08\x0c\x08\x0d\x08\x0e\x08\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x8b\x40\x09\x08\x00\x00\x00\x00\x1a\x04\x14\x08\x0f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x02\x00\x00\x74\x08\x2a\x03\x00\x00\x1b\x00\x17\x08\x17\x08\x32\x08\x00\x00\x00\x00\x00\x00\xe0\x36\xe0\x36\x00\x00\xfa\x07\x00\x00\x5d\x35\x00\x00\x00\x00\x00\x00\x31\x08\x33\x08\xc0\x26\x00\x00\x00\x00\x28\x46\x00\x00\x00\x00\x6d\x08\x87\x08\x00\x00\x00\x00\x5d\x35\x00\x00\x00\x00\x00\x00\x00\x00\x25\x08\x1a\x04\x00\x00\x00\x00\x29\x08\x00\x00\x00\x00\x00\x00\x90\x08\x48\x08\x54\x46\x00\x00\x00\x00\x5f\x36\x1f\x08\xe0\x36\x00\x00\x80\x08\x81\x08\xe5\x3d\x0f\x04\x00\x00\x0f\x04\x0f\x04\x00\x00\x0f\x04\x8b\x40\x00\x00\x00\x00\x05\x40\x00\x00\x00\x00\x00\x00\x00\x00\x27\x08\x54\x08\x00\x00\x0f\x04\x1d\x06\x1d\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x08\x0f\x04\x00\x00\x00\x00\x00\x00\x00\x00"#--happyGotoOffsets :: HappyAddr-happyGotoOffsets = HappyA# "\x05\x00\xfe\xff\x7d\x08\x6e\x4e\x3d\x01\xe4\x50\x12\x50\x13\x07\x70\x4c\x01\x00\xac\x39\x97\x00\x07\x00\xcb\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x04\x00\x00\x00\x00\x00\x00\x8b\x02\x00\x00\x00\x00\x00\x00\x13\x03\x00\x00\x00\x00\xea\x03\x05\x05\xb1\x06\x00\x00\x2a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x1e\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\xd7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\xff\xc8\x39\x57\x3a\xbc\x08\x6e\x08\xd4\x01\xaa\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x92\x07\x59\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x0b\x00\x00\x00\x00\x70\x51\xb6\x51\xaa\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\xfc\x51\xd0\x07\xb4\x4e\xe7\x04\xd7\x07\xdc\x5c\xdb\x07\xf0\x5c\x00\x00\x00\x00\x00\x00\x9a\x5c\x22\x5d\x45\x0c\x32\x5d\x6f\x47\xda\x47\xd6\x45\xb6\x46\x6e\x5e\x99\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x52\xbc\x5a\x69\x3a\xe9\x07\x88\x52\x00\x00\xce\x52\x00\x00\x14\x53\x37\x09\x83\x08\x00\x00\x00\x00\x9a\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x05\x81\xff\x96\x04\x15\x05\x66\x05\x15\x03\xb3\x08\xa0\x01\x46\x46\x00\x00\x00\x00\x64\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x07\x00\x00\x00\x00\x82\x08\x7e\x08\x00\x00\x38\x22\x4a\x08\x85\x00\x85\x05\xbf\x00\x93\x00\x5a\x02\xc8\x03\x00\x00\xe3\x03\x78\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x08\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\xc5\x01\x00\x00\x1a\x03\xa4\x07\xa5\x07\xa6\x07\x95\x08\x00\x00\xee\x02\x00\x00\x57\x04\x00\x00\xc1\x04\x55\x05\xaa\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x5d\xc5\x07\x3f\x03\x00\x00\x00\x00\x59\x08\x00\x00\x00\x00\x00\x00\x60\x08\x00\x00\x00\x00\xbe\x05\x00\x00\xe9\xff\x00\x00\x7b\xff\x8a\x03\x00\x00\x50\x08\x5d\x08\x00\x00\x00\x00\xcf\x04\x4a\x23\x99\x03\x54\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x25\x5c\x24\x3f\x08\x00\x00\x00\x00\xc7\x03\x00\x00\x0e\x5c\x00\x00\x0f\x09\x59\x03\xb1\x07\x86\x08\x00\x00\x00\x00\x00\x00\x34\x12\x96\xff\x00\x00\x00\x00\x02\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x48\x1b\x49\x00\x00\x45\x0c\x00\x00\x00\x00\x4d\x04\x00\x00\x5b\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x25\x00\x00\xf0\x03\x00\x00\x00\x00\x07\x04\xa2\x09\x62\x04\x00\x00\x00\x00\xd5\x02\x54\x03\x8f\x00\x36\x04\xc9\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\xbb\x07\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x28\x00\x00\x00\xce\x12\x00\x00\x00\x00\x00\x00\x88\x03\x16\x08\x00\x00\x96\xff\x00\x00\x00\x00\x00\x00\x45\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x5d\x00\x00\x00\x00\x1e\x5c\x1a\x08\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x4c\xfc\x4c\x00\x00\x00\x00\x00\x00\x26\x08\x87\xff\x00\x00\x00\x00\x47\x4d\x2b\x03\x00\x00\x00\x00\x32\x5e\x5a\x53\xe7\x01\x00\x00\x05\x08\x00\x00\x00\x00\xd0\x5b\x9e\x0a\xa0\x53\xe6\x53\x2c\x54\x72\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x36\x1b\x08\x3f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x02\x00\x00\xb4\x00\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\xa4\x01\xf9\x26\x00\x00\x86\x3a\x98\x3a\x00\x00\x00\x00\xbf\x04\x00\x00\x00\x00\x16\x00\xc2\x07\x00\x00\xa8\x02\x00\x00\xce\x07\xd3\x07\xd0\x08\x00\x00\x00\x00\xd4\x08\x00\x00\x00\x00\xbe\x08\x00\x00\x00\x00\x00\x00\x00\x00\xec\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x3b\x00\x00\x00\x00\xd9\x03\x00\x00\x00\x00\x00\x00\x4d\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x37\x00\x00\xc1\x37\x00\x00\x00\x00\x00\x00\xd3\x37\xf0\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x08\x1c\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x54\xfe\x54\xde\x07\x00\x00\x00\x00\x44\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x4d\x26\x47\x5c\x5c\x84\x08\x86\x49\x00\x00\x8a\x55\x9d\x4b\xf1\x49\x00\x00\xd0\x55\xe4\x4b\x5c\x4a\x00\x00\x9d\xff\x00\x00\x00\x00\x00\x00\xb0\x48\x00\x00\x00\x00\x03\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x83\x01\xe5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x02\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x07\x00\x00\x14\x01\x00\x00\xea\x07\x00\x00\x00\x00\xf8\x00\x00\x00\xed\x07\x00\x00\x00\x00\x00\x00\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\x08\x54\x07\x00\x00\x00\x00\x95\x05\x04\x02\x00\x00\x1d\x05\x00\x00\x00\x00\xce\x12\x00\x00\x00\x00\xd0\x5b\xc7\x4a\x00\x00\xcd\x07\xc4\xff\x00\x00\x00\x00\x00\x00\xe8\x07\x00\x00\x4e\x01\x00\x00\x00\x00\xa9\x00\x00\x00\x16\x56\xdd\x4d\xfa\x27\x9a\x08\xf5\x03\xb2\x08\x00\x00\xcc\x08\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x08\xb8\x04\x58\x05\xc1\x08\x00\x00\x00\x00\xbd\x3a\xc2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xff\xeb\x02\x1e\x08\x85\x0b\x00\x00\xed\xff\xd9\xff\x58\x50\x9e\x50\xa3\x08\x00\x00\x00\x00\x00\x00\xa9\x08\x00\x00\xa0\x08\x00\x00\x00\x00\xd9\x01\x9e\x06\x00\x00\x00\x00\xb2\xff\x42\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x56\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x08\x00\x00\x03\x09\x04\x09\x00\x00\x00\x00\x00\x00\xfa\x02\x00\x00\xf1\x08\x00\x00\x83\x01\x06\x09\xae\x08\xb7\x08\x08\x09\xf6\x08\x00\x00\x00\x00\x52\x06\x00\x00\x00\x00\x00\x00\x7f\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x5b\x1a\x00\xd2\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x02\x00\x00\x00\x00\x4c\x3b\xef\x08\x02\x38\xb1\xff\x00\x00\xe0\x08\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x08\xbe\x09\x00\x00\x00\x00\x91\x38\x00\x00\x00\x00\xea\x02\x00\x00\xdc\x08\x00\x00\x00\x00\xcf\x08\x00\x00\x00\x00\xe1\x05\x00\x00\xfc\x28\x00\x00\xde\x36\xfa\x36\x00\x00\xaa\x08\x98\x04\x00\x00\xad\x38\xce\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x09\x00\x00\x00\x00\xf9\x09\x00\x00\x00\x00\x00\x00\x9f\x05\x00\x00\xcd\x06\xa2\x56\x00\x00\x00\x00\xe0\x0b\xbd\x02\x00\x00\xfe\x29\x5e\x3b\x7c\x3b\xef\x01\x00\x00\x00\x00\x1a\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x0a\x00\x00\x2c\x08\x00\x00\x00\x00\xd3\x08\x00\x00\x28\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x4e\x00\x00\x00\x00\x00\x00\x2e\x57\x86\x4f\x74\x57\x00\x00\x00\x00\x32\x4b\x0c\x02\x00\x00\x00\x00\x00\x00\xc9\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x03\x0b\x3c\x00\x00\xe5\x38\x22\x00\x44\x09\x00\x00\x35\x09\x36\x09\x00\x00\x15\x00\x00\x00\x00\x00\xfb\xff\xfd\xff\x00\x00\x00\x00\xa1\x03\x00\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x08\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x05\xcc\x4f\x00\x00\x00\x00\xba\x57\x00\x58\x00\x00\x00\x00\x2a\x4c\x40\x4f\x46\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x08\xd8\x04\x00\x00\xae\xff\x00\x00\xad\x08\x00\x00\x18\x09\xe3\x04\x00\x00\x3b\x3c\x00\x00\x16\x37\x00\x00\x00\x00\x8c\x58\x00\x00\xd3\x03\x52\x04\x00\x00\xc2\x08\xfc\x05\x00\x00\x00\x00\x00\x00\xc9\x01\x56\x02\x00\x00\x00\x00\x00\x00\x1b\x09\xc5\xff\x00\x00\x00\x00\xf2\x0b\x00\x00\x00\x00\xf4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\xf5\x02\xce\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x09\x00\x00\x00\x00\x50\x09\x33\x09\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x58\x00\x00\x00\x00\x00\x00\xcf\x05\x4e\x06\x00\x00\x00\x00\x1e\x0c\x00\x00\x00\x00\x00\x00\x22\x09\x00\x00\x17\x09\x00\x00\x4e\x08\x00\x00\x00\x00\xaa\x05\x00\x00\x00\x00\xea\x02\x00\x00\x00\x00\x56\x08\x00\x00\x2e\x09\x8e\x5b\xcd\x05\x00\x00\x00\x00\x00\x00\x00\x00\xba\xff\x67\x01\x00\x00\x92\x04\x00\x00\x26\x03\x00\x00\xd5\x08\x00\x00\x62\x05\x00\x00\x00\x00\x8c\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x18\x59\x5e\x59\xa4\x59\x00\x00\x00\x00\x00\x00\x00\x00\x11\x09\x9e\x08\xea\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x08\x00\x00\x00\x00\x26\x00\x00\x00\x69\x09\x00\x00\x00\x00\x54\x00\xe3\xff\x00\x00\x00\x00\x00\x00\x6b\x09\x00\x00\x41\x03\x5b\x03\x00\x00\x27\x00\x65\x09\x00\x00\x00\x00\x00\x00\x00\x00\x76\x08\x68\x04\x4d\x03\x4e\x05\x2b\x00\x00\x00\x00\x00\x00\x00\x03\x00\x86\x09\x00\x00\x29\x00\x7a\x08\x88\x08\x00\x00\x30\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x04\x82\x01\x00\x00\x79\x08\x00\x00\x65\x19\x85\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x05\x00\x00\x59\x09\x9d\x06\x00\x2b\xce\x12\x02\x2c\x00\x00\x00\x00\x00\x00\xd1\x04\x00\x00\x00\x00\x5c\x08\x00\x00\xd3\x02\xd1\x03\x12\x00\x00\x00\x8b\x08\x00\x00\x59\x3c\x00\x00\x69\x06\x8d\x08\x00\x00\x40\x02\x63\x02\x00\x00\x8f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x8a\x02\x00\x00\x91\x08\x00\x00\x93\x08\x00\x00\x00\x00\xd3\xff\x00\x00\x63\x09\x8b\x0c\x66\x09\x00\x00\x00\x00\x74\x39\x90\x39\x00\x00\x00\x00\x23\x01\xbb\x0a\xac\x01\x00\x00\x00\x00\x8e\x08\x00\x00\x00\x00\x00\x00\xa4\x03\x00\x00\x00\x00\x2c\x02\x00\x00\xae\x03\x76\x5a\x00\x00\x00\x00\xa3\x09\xa4\x09\x00\x00\xff\xff\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x02\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x09\x9b\x09\x00\x00\x00\x00\x00\x00\x00\x00\x18\x06\xa2\x04\x00\x00\x6c\x00\x00\x00\x26\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\x08\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x20\x09\x87\x05\x00\x00\x00\x00\x6d\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x05\x00\x00\xf0\xff\x00\x00\x00\x00\x2c\x02\xc3\x03\x5f\x0a\x00\x00\x00\x00\x00\x00\x1f\x00\xa4\x08\x00\x00\x02\x00\xa6\x08\x00\x00\xf5\xff\x5e\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x08\xaa\x09\xb8\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x08\x00\x00\x00\x00\x00\x00\x00\x00"#--happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int#-happyAdjustOffset off = off--happyDefActions :: HappyAddr-happyDefActions = HappyA# "\xc0\xff\xc1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\xfd\x00\x00\x00\x00\xbf\xff\xc0\xff\x00\x00\xf2\xff\x1b\xfd\x18\xfd\x15\xfd\x05\xfd\x03\xfd\x04\xfd\x11\xfd\x02\xfd\x01\xfd\x00\xfd\x13\xfd\x12\xfd\x14\xfd\x10\xfd\x0f\xfd\xff\xfc\xfe\xfc\xfd\xfc\xfc\xfc\xfb\xfc\xfa\xfc\xf9\xfc\xf8\xfc\xf7\xfc\xf5\xfc\xf6\xfc\x00\x00\x16\xfd\x17\xfd\x00\x00\x8b\xff\x00\x00\xb1\xff\xc2\xff\x8b\xff\xd5\xfc\x00\x00\x00\x00\x00\x00\x00\x00\xac\xfe\xab\xfe\x00\x00\x00\x00\xa2\xfe\x9b\xfe\x95\xfe\x92\xfe\x90\xfe\x7e\xfe\x00\x00\x8b\xfe\x4f\xfd\x8f\xfe\x48\xfd\x3d\xfd\x40\xfd\x37\xfd\x8a\xfe\x8e\xfe\x25\xfd\x21\xfd\x74\xfe\x69\xfe\x1f\xfd\x1e\xfd\x20\xfd\x00\x00\x00\x00\x34\xfd\xa8\xfe\x33\xfd\xa9\xfe\x23\xfd\xd1\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\xfd\x3a\xfd\x35\xfd\x36\xfd\x3e\xfd\x38\xfd\x39\xfd\x76\xfd\x75\xfe\x76\xfe\x7c\xfe\x00\x00\x1f\xfe\x1e\xfe\x00\x00\xf1\xff\x65\xfd\x58\xfd\x64\xfd\xef\xff\xf0\xff\x29\xfd\x0d\xfd\x0e\xfd\x09\xfd\x06\xfd\x63\xfd\xf2\xfc\x54\xfd\xef\xfc\xec\xfc\x08\xfd\xf4\xfc\xf3\xfc\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xfc\x07\xfd\xed\xfc\xf1\xfc\x0a\xfd\xee\xfc\xde\xfd\x83\xfd\x18\xfe\x06\xfe\x17\xfe\x00\x00\x00\x00\x07\xfe\xfc\xfd\xf9\xfd\xf7\xfd\xe8\xfd\x00\x00\x00\x00\x88\xfd\x86\xfd\xf4\xfd\xf3\xfd\xf5\xfd\xf6\xfd\xf2\xfd\xe9\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x75\xfd\xeb\xfc\xea\xfc\xf1\xfd\xf0\xfd\xe7\xfc\xe6\xfc\xe9\xfc\xe8\xfc\xe5\xfc\xe4\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xfd\x00\x00\xda\xfd\x00\x00\x00\x00\x78\xff\x2c\xfe\x00\x00\x00\x00\x15\xfe\x00\x00\x18\xfd\x76\xff\x75\xff\x74\xff\x00\x00\x00\x00\x23\xfe\x23\xfe\x23\xfe\x00\x00\x73\xfd\x00\x00\x00\x00\x96\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x6e\xff\x6d\xff\x6c\xff\x1d\xff\x6b\xff\x6a\xff\x38\xfe\x5d\xff\x37\xfe\x40\xfe\x5c\xff\x3b\xfe\x5b\xff\x3f\xfe\x3e\xfe\x3d\xfe\x3c\xfe\x00\x00\x2d\xff\x00\x00\x48\xff\x4c\xff\x2c\xff\x00\x00\x00\x00\x00\x00\xe4\xfe\xcf\xfe\xd4\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xfc\xd8\xfc\xd7\xfc\xd6\xfc\x00\x00\x00\x00\x85\xff\x00\x00\x00\x00\x00\x00\x00\x00\x8b\xff\xc3\xff\x8b\xff\x00\x00\x88\xff\x00\x00\x00\x00\x00\x00\x83\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\xfd\x5f\xfd\x69\xfd\x1d\xfd\x61\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfe\x00\x00\x6b\xfd\x00\x00\xd0\xfe\x00\x00\x00\x00\xe5\xfe\xe2\xfe\x00\x00\x5e\xfd\x00\x00\x00\x00\x00\x00\x68\xff\x00\x00\x00\x00\x00\x00\x9b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\xff\x4b\xff\x4a\xff\x6f\xfe\x00\x00\x66\xfe\x00\x00\x20\xff\x00\x00\x2d\xfd\x00\x00\x2e\xfd\x00\x00\x00\x00\x00\x00\x1d\xff\x00\x00\x95\xfd\xd1\xfd\x18\xfe\x00\x00\x00\x00\x2a\xfd\x00\x00\x2b\xfd\x27\xfd\x0b\xfd\x00\x00\x0c\xfd\x54\xfd\x00\x00\x00\x00\xda\xfc\x08\xfd\x5c\xfd\xde\xfc\x00\x00\x5e\xfd\xb4\xfe\x00\x00\x74\xfd\x72\xfd\x70\xfd\x6f\xfd\x6c\xfd\x00\x00\x00\x00\x00\x00\x22\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xec\xfe\x00\x00\xef\xfe\xef\xfe\x00\x00\x00\x00\x00\x00\x77\xff\xe4\xfd\x52\xfd\xe5\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xff\x6f\xff\x00\x00\x00\x00\x00\x00\xe6\xfd\xe7\xfd\x00\x00\xd7\xfd\xf6\xfd\x00\x00\x00\x00\x0b\xfd\x0c\xfd\x00\x00\x5a\xfd\x00\x00\xb0\xfd\xaf\xfd\x00\x00\xc5\xfd\x00\x00\xc4\xfd\x57\xfd\x93\xfd\x0d\xfe\xfa\xfd\x92\xfd\x8f\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xfd\x85\xfd\x89\xfd\x89\xfd\x00\x00\x0b\xfe\x82\xfd\x03\xfe\x00\x00\x0f\xfe\x9a\xfd\x00\x00\x00\x00\x0c\xfe\x00\x00\x00\x00\x00\x00\x80\xfd\xff\xfd\x00\x00\x0a\xfe\x05\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\xfe\x67\xfd\x66\xfd\x8d\xfe\x8c\xfe\x78\xfe\x30\xfd\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x6e\xfe\x00\x00\x00\x00\x00\x00\x85\xfe\x00\x00\x40\xfd\x00\x00\x00\x00\xa8\xfe\x00\x00\x87\xfe\x00\x00\x4a\xfd\x00\x00\x4b\xfd\x00\x00\x4b\xfe\x49\xfe\xd2\xfc\x00\x00\xa6\xfe\xa7\xfe\x00\x00\x69\xfe\x68\xfe\x00\x00\x00\x00\x91\xfe\x00\x00\x00\x00\xaa\xfe\x89\xfe\x00\x00\x00\x00\xe9\xff\x00\x00\x00\x00\xae\xff\x88\xff\xad\xff\x00\x00\x00\x00\xbc\xff\xe1\xfc\xe0\xfc\xbc\xff\xac\xff\xaa\xff\xab\xff\x8c\xff\xed\xff\xe2\xfc\xe3\xfc\xea\xff\x00\x00\xd9\xff\xdd\xff\xda\xff\xdc\xff\xdb\xff\xde\xff\xec\xff\xa4\xfe\x9a\xfe\xa3\xfe\x00\x00\x6a\xfe\x00\x00\x00\x00\xaf\xfe\x00\x00\x00\x00\x88\xfe\x82\xfe\x00\x00\x81\xfe\x49\xfd\x46\xfd\x4c\xfd\x4e\xfd\xdf\xfc\x47\xfd\x00\x00\x80\xfe\x00\x00\x4d\xfd\x83\xfe\x84\xfe\x00\x00\x00\x00\x24\xfd\x3f\xfd\x00\x00\x00\x00\x00\x00\x34\xfd\x33\xfd\xa9\xfe\x23\xfd\x35\xfd\x36\xfd\x39\xfd\x6e\xfe\x00\x00\x70\xfe\x7d\xfe\xee\xff\x5b\xfd\x62\xfd\x19\xfd\x59\xfd\x53\xfd\x28\xfd\x19\xfe\x1a\xfe\x1b\xfe\x1c\xfe\x1d\xfe\xb2\xfe\x16\xfe\xfe\xfd\x00\x00\x81\xfd\x7e\xfd\x7b\xfd\x7d\xfd\x84\xfd\xfb\xfd\x00\x00\x00\x00\x00\x00\xab\xfd\xa9\xfd\x9b\xfd\x98\xfd\x00\x00\x04\xfe\x00\x00\x00\x00\x00\x00\x8a\xfd\x00\x00\x00\x00\x02\xfe\x01\xfe\x00\x00\x91\xfd\x11\xfe\x00\x00\x00\x00\x8f\xfd\xb6\xfe\x00\x00\xeb\xfd\xc3\xfd\x00\x00\x00\x00\xea\xfd\x00\x00\x00\x00\x00\x00\x1a\xfd\xc7\xfd\xcb\xfd\xec\xfd\xcd\xfd\xc6\xfd\xcc\xfd\xed\xfd\x00\x00\xe3\xfd\xe0\xfd\xe1\xfd\xd2\xfd\xd3\xfd\x00\x00\x00\x00\xdf\xfd\xe2\xfd\xdb\xfd\xd9\xfd\x50\xfd\x00\x00\x00\x00\x51\xfd\x2d\xfe\x31\xfd\x72\xff\x32\xfd\x56\xfd\x00\x00\x2f\xfe\xb1\xfe\x00\x00\x9e\xfe\x99\xfe\x00\x00\x69\xfe\x00\x00\x00\x00\x36\xfe\xf0\xfe\xb8\xfe\x35\xfe\x00\x00\x78\xfd\xf4\xfd\x00\x00\x00\x00\x00\x00\x73\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xfc\xdb\xfc\x1a\xfd\xcf\xfd\xee\xfd\xef\xfd\xd0\xfd\x00\x00\x00\x00\x00\x00\x2b\xff\x00\x00\xb7\xfe\x00\x00\x99\xfe\x00\x00\x69\xfe\x14\xfe\x39\xfe\xe8\xfe\x31\xfe\x00\x00\x00\x00\x00\x00\xfd\xfe\x61\xfe\x29\xff\x00\x00\x4c\xff\x4d\xff\x4e\xff\x50\xff\x4f\xff\xf3\xfe\x1a\xff\x00\x00\x27\xff\x53\xff\x00\x00\x00\x00\x00\x00\xc2\xfe\xc1\xfe\xc0\xfe\xbf\xfe\xbe\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x11\xff\x0e\xff\x00\x00\x00\x00\x00\x00\xdc\xfe\xe1\xfe\x00\x00\x65\xff\xe6\xfe\xce\xfe\xc9\xfe\xcd\xfe\x67\xff\xd1\xfe\x00\x00\xd3\xfe\x66\xff\xd6\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\xff\x3a\xfe\x86\xff\x7f\xff\x84\xff\xbc\xff\xbc\xff\xb8\xff\xb7\xff\xb4\xff\x6f\xff\xb9\xff\x8a\xff\xb5\xff\xb6\xff\xa8\xff\x00\x00\x00\x00\xa8\xff\x81\xff\x80\xff\x61\xff\x00\x00\x00\x00\x5e\xff\x62\xff\x00\x00\xc8\xfe\xc6\xfe\x00\x00\xd7\xfe\x6a\xfd\xd2\xfe\x00\x00\xca\xfe\xe7\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x13\xff\x14\xff\x00\x00\x0c\xff\x0d\xff\x08\xff\x00\x00\x10\xff\x00\x00\xc4\xfe\x00\x00\xbc\xfe\xbb\xfe\xbd\xfe\x00\x00\xc3\xfe\x59\xff\x00\x00\x47\xff\x00\x00\x00\x00\x1b\xff\x19\xff\x18\xff\x15\xff\x16\xff\x54\xff\x00\x00\x00\x00\x69\xff\x55\xff\x00\x00\x65\xfe\x63\xfe\x00\x00\x5a\xff\x00\x00\x21\xff\x00\x00\xe8\xfe\x33\xfe\x32\xfe\x00\x00\x00\x00\x00\x00\x98\xfe\x00\x00\x00\x00\x2c\xfd\x5c\xfe\x47\xfe\x00\x00\x00\x00\x2b\xff\x1e\xff\x00\x00\xce\xfd\xca\xfd\xdd\xfc\x26\xfd\x5d\xfd\xb3\xfe\x2b\xfe\x71\xfd\x6e\xfd\x60\xfd\x6d\xfd\x28\xfe\x00\x00\x21\xfe\x00\x00\x00\x00\x25\xfe\x2a\xfe\xeb\xfe\x79\xfd\xee\xfe\xf1\xfe\x00\x00\xea\xfe\xed\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfd\xd4\xfd\x71\xff\xd6\xfd\xd8\xfd\xdd\xfd\xc9\xfd\xc8\xfd\xd1\xfd\xbd\xfd\xac\xfd\xbc\xfd\xba\xfd\xb7\xfd\xb6\xfd\x00\x00\xae\xfd\xd1\xfd\xbf\xfd\xc1\xfd\xbe\xfd\x00\x00\x00\x00\x90\xfd\x00\x00\xa4\xfd\xa0\xfd\xb6\xfe\xa5\xfd\x00\x00\x00\x00\xa6\xfd\x00\x00\x08\xfe\x8e\xfd\x8b\xfd\x8d\xfd\x09\xfe\x12\xfe\x00\x00\x00\x00\x00\x00\x99\xfd\x0e\xfe\x00\x00\x00\x00\xf8\xfd\x79\xfe\x1c\xfd\x00\x00\x2f\xfd\x6d\xfe\x6c\xfe\x6b\xfe\x00\x00\x5f\xfe\x00\x00\x00\x00\xd3\xfc\x00\x00\xa5\xfe\x00\x00\x00\x00\x00\x00\xeb\xff\xa8\xff\xa8\xff\x00\x00\xa1\xff\x00\x00\xe8\xff\xc1\xff\xc1\xff\xd8\xff\x00\x00\xd3\xfc\xd4\xfc\xd1\xfc\x77\xfe\x7f\xfe\x86\xfe\x00\x00\x7f\xfd\x7c\xfd\x97\xfd\xaa\xfd\x03\xfe\x8c\xfd\x00\x00\xa8\xfd\xa3\xfd\x00\x00\xa1\xfd\xa7\xfd\xb5\xfe\x00\x00\xc2\xfd\xb5\xfd\xfa\xfc\x00\x00\x00\x00\x00\x00\x70\xff\x8d\xff\x73\xff\xa0\xfe\x97\xfe\x9f\xfe\x00\x00\xb0\xfe\x2e\xfe\x77\xfd\xf2\xfe\x7a\xfd\x00\x00\xae\xfe\x00\x00\x20\xfe\x00\x00\x1f\xff\x5c\xfe\x47\xfe\x2a\xff\xd1\xfc\x57\xff\x46\xfe\x44\xfe\x48\xff\x47\xfe\x00\x00\x00\x00\x9f\xfe\x00\x00\xe9\xfe\x34\xfe\x00\x00\xfe\xfe\x01\xff\x01\xff\x60\xfe\x61\xfe\x61\xfe\x28\xff\x1c\xff\xf4\xfe\xf7\xfe\xf7\xfe\x17\xff\x25\xff\x26\xff\x42\xff\x00\x00\x38\xff\x00\x00\x00\x00\xc5\xfe\x55\xfd\x00\x00\x0f\xff\x12\xff\x00\x00\x00\x00\xdb\xfe\xd9\xfe\x00\x00\x00\x00\xe0\xfe\xde\xfe\x00\x00\xcc\xfe\x00\x00\xc7\xfe\x00\x00\x64\xff\x00\x00\x00\x00\x82\xff\x00\x00\x00\x00\x00\x00\x00\x00\x89\xff\x8e\xff\x00\x00\xbe\xff\xbd\xff\x00\x00\x7d\xff\x5f\xff\x60\xff\xcb\xfe\xdf\xfe\x00\x00\x00\x00\xda\xfe\xdd\xfe\xef\xfe\xef\xfe\x0b\xff\xb9\xfe\x00\x00\x46\xff\x00\x00\x58\xff\x00\x00\xfc\xfe\x1d\xff\xf8\xfe\x00\x00\xfb\xfe\x2d\xff\x00\x00\x00\x00\x64\xfe\x62\xfe\x07\xff\x02\xff\x00\x00\x06\xff\x32\xff\x00\x00\x00\x00\x00\x00\x30\xfe\xa1\xfe\x96\xfe\x59\xfe\x59\xfe\x56\xff\x00\x00\x45\xfe\x55\xfe\x53\xfe\x4f\xfe\x52\xff\x47\xfe\x26\xfe\x27\xfe\x00\x00\xad\xfd\xb9\xfd\xb8\xfd\xbb\xfd\x00\x00\x00\x00\x00\x00\xc0\xfd\x13\xfe\xa2\xfd\x9f\xfd\xe8\xfe\x9c\xfd\x00\x00\x00\x00\x00\x00\x7a\xfe\x4a\xfe\x48\xfe\x67\xfe\x00\x00\xcc\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\xff\xa3\xff\xa1\xff\x9e\xff\x9f\xff\xa0\xff\x00\x00\xb2\xff\x8b\xff\x8b\xff\xa2\xff\xa1\xff\x9a\xff\x92\xff\x8f\xff\x45\xfd\x90\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa1\xff\xa9\xff\xb3\xff\xd0\xff\xcd\xff\xd7\xff\xe7\xff\xf5\xfc\x00\x00\x00\x00\xcf\xff\x00\x00\x00\x00\x9d\xfd\x9e\xfd\xb4\xfd\xb3\xfd\x00\x00\xad\xfe\x51\xff\x00\x00\x69\xfe\x00\x00\x3c\xfd\x43\xfe\x00\x00\x00\x00\x5a\xfe\x57\xfe\x00\x00\x00\x00\x00\x00\x00\xff\x03\xff\x34\xff\x24\xff\x00\x00\x00\x00\x00\x00\x00\x00\x31\xff\xff\xfe\xf6\xfe\xf9\xfe\x30\xff\xf5\xfe\x00\x00\x41\xff\x39\xff\x39\xff\x00\x00\xba\xfe\x00\x00\x00\x00\x00\x00\xe3\xfe\x7b\xff\x00\x00\xc5\xff\x8b\xff\x8b\xff\xc4\xff\x00\x00\x00\x00\x7e\xff\x87\xff\x7c\xff\x00\x00\xa1\xff\x00\x00\x0a\xff\x09\xff\x45\xff\x43\xff\x00\x00\x3a\xff\x00\x00\x00\x00\x00\x00\x2b\xff\xfa\xfe\x29\xff\x00\x00\x24\xff\x33\xff\x36\xff\x00\x00\x00\x00\x04\xff\x5e\xfe\x00\x00\x00\x00\x59\xfe\x5d\xfe\x72\xfe\x99\xfe\x00\x00\x42\xfe\x3b\xfd\xd3\xfc\x00\x00\x00\x00\x4e\xfe\x93\xfe\xd3\xfc\x00\x00\x00\x00\x10\xfe\xc8\xff\xc9\xff\xc6\xff\x00\x00\xc7\xff\x00\x00\xce\xff\xa7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xff\x00\x00\x91\xff\x9c\xff\x9d\xff\x98\xff\xa4\xff\xaf\xff\xb0\xff\xa1\xff\x00\x00\x97\xff\x95\xff\x94\xff\x93\xff\x44\xfd\x43\xfd\x41\xfd\x42\xfd\x00\x00\xd3\xff\xd1\xff\x00\x00\xe3\xff\x00\x00\xa8\xff\xa8\xff\x00\x00\xb2\xfd\x51\xfe\x94\xfe\x00\x00\x00\x00\x50\xfe\xd1\xfc\x41\xfe\x00\x00\x5b\xfe\x56\xfe\x58\xfe\x00\x00\x8a\xfe\x00\x00\x23\xff\x35\xff\x00\x00\x05\xff\x37\xff\x5c\xfe\x47\xfe\x3e\xff\x40\xff\x3b\xff\x3d\xff\x3f\xff\x44\xff\xd8\xfe\x00\x00\xa1\xff\xbb\xff\xba\xff\x00\x00\x7a\xff\x3c\xff\x2f\xff\x47\xfe\x8a\xfe\x00\x00\x71\xfe\x54\xfe\x4e\xfe\xd3\xfc\x4d\xfe\x00\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xff\xe4\xff\x00\x00\xd6\xff\xd4\xff\x00\x00\x99\xff\xa5\xff\xa3\xff\x96\xff\xd5\xff\xd2\xff\xe5\xff\x00\x00\x00\x00\xe2\xff\x00\x00\x00\x00\x00\x00\x52\xfe\x22\xff\x2e\xff\x79\xff\xca\xff\xcb\xff\x00\x00\x00\x00\xe1\xff\xdf\xff\xe0\xff"#--happyCheck :: HappyAddr-happyCheck = HappyA# "\xff\xff\x00\x00\x0d\x00\x3a\x00\x05\x00\x06\x00\x23\x00\x24\x00\x06\x00\x44\x00\x0f\x00\x10\x00\x0f\x00\x10\x00\x13\x00\x11\x00\x13\x00\x13\x00\x4e\x00\x10\x00\x0c\x00\x0d\x00\x13\x00\x12\x00\x13\x00\x14\x00\x13\x00\x14\x00\x4e\x00\x18\x00\x08\x00\x09\x00\x0a\x00\x4e\x00\x1b\x00\x04\x00\x1d\x00\x73\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x04\x00\x09\x00\x0a\x00\x04\x00\x08\x00\x09\x00\x0a\x00\x08\x00\x09\x00\x0a\x00\x44\x00\x5c\x00\x21\x00\x22\x00\x23\x00\x24\x00\x21\x00\x22\x00\x23\x00\x24\x00\x7c\x00\x21\x00\x22\x00\x23\x00\x24\x00\x13\x00\x5b\x00\x22\x00\x23\x00\x24\x00\x5b\x00\x98\x00\x23\x00\x24\x00\x3b\x00\x3c\x00\x23\x00\x24\x00\x5c\x00\xa3\x00\xa4\x00\x7b\x00\x7c\x00\x13\x00\x01\x00\x45\x00\x00\x00\x9f\x00\xa0\x00\xa1\x00\x0a\x00\x00\x00\xa7\x00\xa8\x00\xa9\x00\xcb\x00\x00\x00\x3b\x00\x3c\x00\xde\x00\xa2\x00\x35\x00\xcb\x00\x00\x00\x56\x00\x00\x00\x51\x00\x11\x00\x97\x00\x98\x00\xa2\x00\x50\x00\x51\x00\x4f\x00\x19\x00\xa2\x00\x34\x00\x35\x00\xfd\x00\x25\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x2a\x00\x2b\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x4d\x00\x0c\x00\x29\x00\x2a\x00\x2b\x00\x70\x00\x71\x00\x51\x00\x4d\x00\x4f\x00\x54\x00\x6c\x00\x56\x00\x77\x00\x63\x00\x19\x00\x5a\x00\x72\x00\x68\x00\x01\x00\x11\x00\x64\x00\x20\x01\x78\x00\x63\x00\x8a\x00\x1e\x01\x7c\x00\x00\x00\x00\x00\x47\x00\x70\x00\x71\x00\xf4\x00\xf5\x00\x2d\x00\x22\x01\x89\x00\xf9\x00\x15\x00\xfb\x00\xfc\x00\x54\x00\x81\x00\x71\x00\x73\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x78\x00\x80\x00\x89\x00\x24\x01\x89\x00\x26\x01\x6b\x00\x66\x00\x89\x00\x0f\x01\x24\x01\x11\x01\x66\x00\x12\x01\x8a\x00\xfd\x00\x15\x01\x66\x00\x71\x00\x75\x00\x89\x00\x1b\x01\x1b\x01\x71\x00\x66\x00\x1e\x01\x66\x00\x09\x01\x0a\x01\x12\x01\x27\x01\x11\x01\x15\x01\x1e\x01\xc8\x00\x71\x00\x2d\x01\x71\x00\x1b\x01\x27\x01\x5a\x00\x1b\x01\x27\x01\x19\x01\x1a\x01\x2d\x01\x1c\x01\x0f\x01\x2d\x01\x11\x01\x20\x01\x12\x01\x27\x01\x7c\x00\x15\x01\x15\x01\x67\x00\xc8\x00\x2d\x01\x1b\x01\x1b\x01\x1b\x01\x27\x01\x64\x00\x54\x00\xf7\x00\xf8\x00\x27\x01\x2d\x01\xfb\x00\xfc\x00\x15\x01\xfe\x00\x2d\x01\x11\x01\x15\x01\x71\x00\x1b\x01\x72\x00\x73\x00\x66\x00\x1b\x01\x15\x01\x27\x01\x1b\x01\x29\x01\x2a\x01\x0d\x01\x1b\x01\xa4\x00\x82\x00\x71\x00\x6a\x00\x13\x01\x14\x01\x15\x01\x16\x01\x23\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x23\x01\x11\x01\x50\x00\x23\x01\x2b\x01\x00\x00\x2b\x01\x2b\x01\x13\x00\x23\x01\x89\x00\x1b\x01\x2b\x01\x15\x01\x2b\x01\x1b\x01\x2b\x01\x74\x00\x75\x00\x1b\x01\x82\x00\x58\x00\xa8\x00\xa9\x00\x1b\x01\x5c\x00\x27\x01\x1b\x01\x29\x01\x2a\x01\x27\x01\x1b\x01\x29\x01\x2a\x01\x1b\x01\x27\x01\x72\x00\x29\x01\x2a\x01\x15\x01\x27\x01\x34\x00\x29\x01\x2a\x01\x27\x01\x1b\x01\x29\x01\x2a\x01\x27\x01\x98\x00\x29\x01\x2a\x01\x02\x01\x13\x00\x04\x01\x00\x00\x06\x01\x02\x01\xb3\x00\x04\x01\x19\x00\x06\x01\x02\x01\x00\x00\x04\x01\x64\x00\x06\x01\x50\x00\x51\x00\x13\x01\x14\x01\x15\x01\x97\x00\x98\x00\x13\x01\x14\x01\x15\x01\x1b\x01\x71\x00\x13\x01\x14\x01\x15\x01\x1b\x01\x7d\x00\x39\x00\x14\x00\x34\x00\x1b\x01\x3d\x00\x3e\x00\x3f\x00\x40\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x12\x01\x3e\x00\x3f\x00\x15\x01\x4d\x00\xf4\x00\xf5\x00\x00\x00\x4d\x00\x1b\x01\xf9\x00\x66\x00\xfb\x00\xfc\x00\x50\x00\x54\x00\x55\x00\x27\x01\x31\x00\x32\x00\x59\x00\x89\x00\x71\x00\x2d\x01\x15\x01\x5e\x00\x64\x00\x13\x00\x00\x00\x58\x00\x1b\x01\x12\x01\x58\x00\x1e\x01\x15\x01\x12\x01\x0c\x00\x63\x00\x15\x01\x71\x00\x1b\x01\x97\x00\x98\x00\x54\x00\x1b\x01\x4d\x00\x6b\x00\x1e\x01\x72\x00\xf4\x00\xf5\x00\x78\x00\x1c\x00\x27\x01\xf9\x00\x80\x00\xfb\x00\xfc\x00\x39\x00\x2d\x01\x34\x00\x66\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xa1\x00\x4d\x00\x12\x01\x66\x00\x81\x00\x15\x01\x0f\x01\x81\x00\x11\x01\x89\x00\x9b\x00\x1b\x01\x4d\x00\x12\x01\x71\x00\x71\x00\x15\x01\x56\x00\x1b\x01\x54\x00\x55\x00\x5a\x00\x1b\x01\x54\x00\x59\x00\x1e\x01\x19\x00\x6e\x00\x54\x00\x5e\x00\x0f\x01\x72\x00\x11\x01\x97\x00\x98\x00\x4e\x00\x33\x00\x71\x00\xad\x00\xae\x00\xaf\x00\x54\x00\x1b\x01\x66\x00\x64\x00\xb4\x00\x2d\x00\x6c\x00\xb7\x00\x54\x00\xfe\x00\xba\x00\xbb\x00\x72\x00\x71\x00\x78\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x39\x00\x0b\x01\x66\x00\x0d\x01\x9f\x00\xa0\x00\xa1\x00\x8a\x00\x9b\x00\x72\x00\x50\x00\x67\x00\x16\x01\x71\x00\x18\x01\x19\x01\x1a\x01\x72\x00\x1c\x01\x4c\x00\x4d\x00\x1f\x01\x20\x01\x97\x00\x98\x00\x4e\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x5a\x00\x54\x00\x59\x00\x0f\x01\x72\x00\x11\x01\x80\x00\x5e\x00\x6c\x00\x4d\x00\xed\x00\xee\x00\x63\x00\x64\x00\x72\x00\x1b\x01\xad\x00\xae\x00\xaf\x00\x64\x00\xf7\x00\xf8\x00\x14\x00\xb4\x00\xfb\x00\xfc\x00\xb7\x00\x89\x00\x64\x00\xba\x00\xbb\x00\x72\x00\x71\x00\x1e\x01\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x64\x00\x71\x00\x4f\x00\x9f\x00\xa0\x00\xa1\x00\x75\x00\x12\x01\x13\x01\x14\x01\x15\x01\x31\x00\x32\x00\x71\x00\x5b\x00\x5c\x00\x1b\x01\x19\x00\x1d\x01\x1e\x01\x61\x00\x0f\x01\x21\x01\x11\x01\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x54\x00\x1b\x01\x75\x00\x51\x00\x50\x00\x2d\x00\x73\x00\x55\x00\xed\x00\xee\x00\x77\x00\x78\x00\x54\x00\x80\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xf7\x00\xf8\x00\x19\x00\xb4\x00\xfb\x00\xfc\x00\xb7\x00\x6c\x00\x6e\x00\xba\x00\xbb\x00\x1e\x01\x72\x00\x72\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x27\x01\x39\x00\x2d\x00\x0f\x01\x72\x00\x11\x01\x2d\x01\x12\x01\x13\x01\x14\x01\x15\x01\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x1b\x01\x1b\x01\x4f\x00\x1d\x01\x1e\x01\x4c\x00\x4d\x00\x21\x01\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x1e\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x64\x00\x59\x00\x84\x00\x85\x00\x86\x00\x0f\x01\x5e\x00\x11\x01\xed\x00\xee\x00\x2d\x00\x63\x00\x64\x00\x71\x00\x6c\x00\x91\x00\x1e\x01\x1b\x01\xf7\x00\xf8\x00\x72\x00\x6c\x00\xfb\x00\xfc\x00\x4d\x00\x1f\x00\x78\x00\x72\x00\x1e\x01\x07\x01\x08\x01\xf4\x00\xf5\x00\xe8\x00\xe9\x00\xea\x00\xf9\x00\x27\x01\xfb\x00\xfc\x00\x2e\x00\x2f\x00\x04\x01\x2d\x01\x06\x01\x12\x01\x13\x01\x14\x01\x15\x01\x68\x00\x64\x00\x2d\x00\x2e\x00\xb7\x00\x1b\x01\x11\x01\x1d\x01\x1e\x01\x24\x01\x72\x00\x21\x01\x12\x01\xfd\x00\x71\x00\x15\x01\x1b\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x1b\x01\xe9\x00\xea\x00\x1e\x01\x09\x01\x0a\x01\x13\x01\x14\x01\x15\x01\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x9b\x00\x1b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x64\x00\x19\x01\x1a\x01\xb4\x00\x1c\x01\x6c\x00\xb7\x00\x39\x00\x20\x01\xba\x00\xbb\x00\x72\x00\x68\x00\x71\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x48\x00\x49\x00\x5b\x00\x5c\x00\x13\x01\x14\x01\x15\x01\x1e\x01\x61\x00\x56\x00\x5b\x00\x5c\x00\x1b\x01\x5a\x00\xfd\x00\x30\x00\x61\x00\x00\x01\x01\x01\x59\x00\x55\x00\x04\x01\x1e\x00\x06\x01\x5e\x00\x1a\x00\x3b\x00\x3c\x00\x6b\x00\x54\x00\x77\x00\x56\x00\x0f\x01\x67\x00\x11\x01\x4f\x00\x63\x00\x2d\x00\x77\x00\x76\x00\xed\x00\xee\x00\x7b\x00\x7a\x00\x1b\x01\x2e\x00\x2f\x00\x5b\x00\x5c\x00\x20\x01\xf7\x00\xf8\x00\xf5\x00\x61\x00\xfb\x00\xfc\x00\xf9\x00\x15\x01\xfb\x00\xfc\x00\x84\x00\x85\x00\x86\x00\x1b\x01\x6c\x00\x1d\x01\x1e\x01\x8b\x00\x1e\x00\x8d\x00\x72\x00\x8f\x00\x90\x00\x91\x00\x4e\x00\x77\x00\x78\x00\x12\x01\x13\x01\x14\x01\x15\x01\x12\x01\x56\x00\x2d\x00\x15\x01\x68\x00\x1b\x01\x76\x00\x1d\x01\x1e\x01\x1b\x01\x7a\x00\x21\x01\x1e\x01\x1e\x00\x72\x00\x27\x01\x6b\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x2d\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x4e\x00\x76\x00\x2d\x00\xb4\x00\xb7\x00\x7a\x00\xb7\x00\x39\x00\x56\x00\xba\x00\xbb\x00\x4f\x00\x68\x00\x55\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x58\x00\x11\x01\x72\x00\x5b\x00\x4f\x00\xb1\x00\xb2\x00\xb3\x00\x84\x00\x85\x00\x86\x00\x1b\x01\x6b\x00\x58\x00\x6e\x00\x9b\x00\x5b\x00\x5c\x00\x72\x00\x59\x00\x90\x00\x91\x00\x61\x00\x76\x00\x5e\x00\x1f\x01\x20\x01\x7a\x00\x15\x01\x57\x00\x24\x01\x77\x00\x78\x00\x67\x00\x1b\x01\x7b\x00\x7c\x00\x1e\x01\xeb\x00\xec\x00\xed\x00\xee\x00\x80\x00\x12\x01\x77\x00\x78\x00\x15\x01\x80\x00\x7b\x00\x7c\x00\xf7\x00\xf8\x00\x1b\x01\x12\x01\xfb\x00\xfc\x00\x15\x01\x00\x01\x01\x01\xb7\x00\x03\x01\x04\x01\x1b\x01\x06\x01\x07\x01\x08\x01\x72\x00\x6e\x00\x13\x01\x14\x01\x15\x01\x72\x00\x0f\x01\x10\x01\x11\x01\x81\x00\x1b\x01\x12\x01\x13\x01\x14\x01\x15\x01\x67\x00\x02\x00\x03\x00\x1b\x01\x6b\x00\x1b\x01\x6d\x00\x1d\x01\x1e\x01\x6e\x00\x71\x00\x21\x01\x9b\x00\x72\x00\x0f\x01\x76\x00\x11\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x15\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x1b\x01\x1b\x01\xdc\x00\xb4\x00\xde\x00\x15\x01\xb7\x00\x39\x00\x89\x00\xba\x00\xbb\x00\x1b\x01\x50\x00\x51\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x48\x00\x49\x00\x72\x00\x76\x00\x4a\x00\x00\x01\x01\x01\x7a\x00\x03\x01\x04\x01\x4d\x00\x06\x01\x07\x01\x08\x01\x51\x00\x13\x01\x14\x01\x15\x01\x67\x00\x59\x00\x0f\x01\x10\x01\x11\x01\x1b\x01\x5e\x00\x5f\x00\x60\x00\x67\x00\x9b\x00\x69\x00\x67\x00\x6b\x00\x1b\x01\x6d\x00\x6b\x00\x23\x00\x6d\x00\x80\x00\xeb\x00\xec\x00\xed\x00\xee\x00\x76\x00\xf7\x00\xf8\x00\x76\x00\x7a\x00\xfb\x00\xfc\x00\x7a\x00\xf7\x00\xf8\x00\x27\x01\x67\x00\xfb\x00\xfc\x00\x6b\x00\x6b\x00\x2d\x01\x6d\x00\x84\x00\x85\x00\x86\x00\x19\x01\x1a\x01\x18\x00\x1c\x01\x8b\x00\x76\x00\x8d\x00\x20\x01\x8f\x00\x90\x00\x91\x00\x24\x01\x3e\x00\x3f\x00\x12\x01\x13\x01\x14\x01\x15\x01\x1d\x01\x1e\x01\x4d\x00\x14\x01\x15\x01\x1b\x01\x51\x00\x1d\x01\x1e\x01\x9b\x00\x1b\x01\x21\x01\x1d\x01\x1e\x01\xb1\x00\xb2\x00\xb3\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x39\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\x63\x00\x76\x00\x65\x00\xb4\x00\xb7\x00\x7a\x00\xb7\x00\x39\x00\x4f\x00\xba\x00\xbb\x00\x9a\x00\x9b\x00\x9c\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x5b\x00\x5c\x00\x01\x01\x9b\x00\x4a\x00\x04\x01\x61\x00\x06\x01\x18\x01\x19\x01\x1a\x01\x89\x00\x1c\x01\x8b\x00\x8c\x00\x1f\x01\x20\x01\x6c\x00\x20\x01\x59\x00\x24\x01\x34\x00\x24\x01\x72\x00\x5e\x00\x5f\x00\x60\x00\x9b\x00\x77\x00\x78\x00\x13\x00\x81\x00\x7b\x00\x7c\x00\x84\x00\x85\x00\x86\x00\x64\x00\x88\x00\x89\x00\xed\x00\xee\x00\x8c\x00\x8d\x00\x28\x01\x8f\x00\x90\x00\x91\x00\x2c\x01\x28\x01\xf7\x00\xf8\x00\x28\x01\x2c\x01\xfb\x00\xfc\x00\x2c\x01\x00\x01\x01\x01\x4d\x00\x03\x01\x04\x01\x28\x01\x06\x01\x07\x01\x08\x01\x2c\x01\x13\x01\x14\x01\x15\x01\x3e\x00\x3f\x00\x0f\x01\x10\x01\x11\x01\x1b\x01\x71\x00\x12\x01\x13\x01\x14\x01\x15\x01\x50\x00\x51\x00\x28\x01\x1b\x01\xb7\x00\x1b\x01\x2c\x01\x1d\x01\x1e\x01\x19\x01\x1a\x01\x21\x01\x1c\x01\x13\x01\x14\x01\x15\x01\x4d\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x1b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x13\x01\x14\x01\x15\x01\xb4\x00\x02\x00\x03\x00\xb7\x00\x39\x00\x1b\x01\xba\x00\xbb\x00\x56\x00\x57\x00\x58\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x63\x00\x49\x00\x65\x00\x13\x01\x14\x01\x15\x01\x4c\x00\x4d\x00\x84\x00\x85\x00\x86\x00\x1b\x01\xed\x00\x51\x00\x8a\x00\x84\x00\x85\x00\x86\x00\x8e\x00\x59\x00\x51\x00\x91\x00\x1f\x00\x54\x00\x5e\x00\x8e\x00\x76\x00\x51\x00\x91\x00\x63\x00\x54\x00\x00\x01\x01\x01\x72\x00\x03\x01\x04\x01\x67\x00\x06\x01\x07\x01\x08\x01\xed\x00\xee\x00\xa6\x00\xaa\x00\xab\x00\xac\x00\x0f\x01\x10\x01\x11\x01\xa6\x00\xf7\x00\xf8\x00\xb5\x00\xb6\x00\xfb\x00\xfc\x00\x68\x00\x69\x00\x1b\x01\xb7\x00\x84\x00\x85\x00\x86\x00\xff\x00\x00\x01\x01\x01\xb7\x00\x8b\x00\x04\x01\x8d\x00\x06\x01\x8f\x00\x90\x00\x91\x00\x14\x01\x15\x01\x50\x00\x12\x01\x13\x01\x14\x01\x15\x01\x1b\x01\x01\x01\x1d\x01\x1e\x01\x04\x01\x1b\x01\x06\x01\x1d\x01\x1e\x01\x51\x00\x63\x00\x21\x01\x65\x00\x13\x01\x14\x01\x15\x01\x56\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x1b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\xaa\x00\xab\x00\xac\x00\xb4\x00\xb7\x00\x4d\x00\xb7\x00\x39\x00\x4d\x00\xba\x00\xbb\x00\xaa\x00\xab\x00\xac\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x04\x01\x05\x01\x06\x01\x4d\x00\x4a\x00\x00\x01\x01\x01\x11\x00\x63\x00\x04\x01\x65\x00\x06\x01\x00\x01\x01\x01\x4d\x00\x63\x00\x04\x01\x65\x00\x06\x01\x59\x00\x0f\x01\x63\x00\x11\x01\x65\x00\x5e\x00\x5f\x00\x63\x00\x0f\x01\x65\x00\x11\x01\x54\x00\xf6\x00\x1b\x01\xf8\x00\x5a\x00\x63\x00\xfb\x00\x65\x00\x47\x00\x1b\x01\xed\x00\xee\x00\xff\x00\x00\x01\x01\x01\x80\x00\x63\x00\x04\x01\x65\x00\x06\x01\xf7\x00\xf8\x00\xb5\x00\xb6\x00\xfb\x00\xfc\x00\x56\x00\x00\x01\x01\x01\x12\x01\x03\x01\x04\x01\x15\x01\x06\x01\x07\x01\x08\x01\x6c\x00\x63\x00\x1b\x01\x65\x00\x1d\x01\x1e\x01\x0f\x01\x10\x01\x11\x01\x68\x00\x69\x00\x12\x01\x13\x01\x14\x01\x15\x01\xda\x00\xdb\x00\xdc\x00\x1b\x01\xde\x00\x1b\x01\x6c\x00\x1d\x01\x1e\x01\x6b\x00\x6c\x00\x21\x01\x49\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x6c\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\x18\x01\x19\x01\x1a\x01\xb4\x00\x1c\x01\x6c\x00\xb7\x00\x39\x00\x6c\x00\xba\x00\xbb\x00\xaa\x00\xab\x00\xac\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x63\x00\x49\x00\x65\x00\x4f\x00\x50\x00\x51\x00\xb5\x00\xb6\x00\x54\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x72\x00\x5b\x00\x5c\x00\x50\x00\x63\x00\x59\x00\x65\x00\x61\x00\x6d\x00\x6e\x00\x5e\x00\x84\x00\x85\x00\x86\x00\xaa\x00\xab\x00\xac\x00\x4d\x00\x8b\x00\x67\x00\x8d\x00\x54\x00\x8f\x00\x90\x00\x91\x00\x73\x00\xed\x00\xee\x00\x0d\x00\x77\x00\x78\x00\x25\x01\x26\x01\x7b\x00\x7c\x00\x72\x00\xf7\x00\xf8\x00\x68\x00\x69\x00\xfb\x00\xfc\x00\xaa\x00\xab\x00\xac\x00\x68\x00\x84\x00\x85\x00\x86\x00\xff\x00\x00\x01\x01\x01\x6a\x00\x8b\x00\x04\x01\x8d\x00\x06\x01\x8f\x00\x90\x00\x91\x00\x07\x01\x08\x01\xb7\x00\x12\x01\x13\x01\x14\x01\x15\x01\x18\x01\x19\x01\x1a\x01\x6c\x00\x1c\x01\x1b\x01\x6c\x00\x1d\x01\x1e\x01\x93\x00\x63\x00\x21\x01\x65\x00\x63\x00\x63\x00\x65\x00\x65\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x91\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\x63\x00\x91\x00\x65\x00\xb4\x00\xb7\x00\x91\x00\xb7\x00\x39\x00\x6e\x00\xba\x00\xbb\x00\xec\x00\xed\x00\x6c\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\x00\x00\x01\x01\x01\x9b\x00\x9c\x00\x04\x01\x72\x00\x06\x01\x84\x00\x85\x00\x86\x00\x36\x00\x37\x00\x6a\x00\x68\x00\x72\x00\x81\x00\x4d\x00\x8e\x00\x59\x00\x4d\x00\x91\x00\x00\x01\x01\x01\x5e\x00\x03\x01\x04\x01\x4d\x00\x06\x01\x07\x01\x08\x01\x56\x00\x0d\x00\x67\x00\x71\x00\x54\x00\x15\x00\x0f\x01\x10\x01\x11\x01\xed\x00\xee\x00\x73\x00\x73\x00\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x73\x00\x1b\x01\xf7\x00\xf8\x00\x6e\x00\x6a\x00\xfb\x00\xfc\x00\x73\x00\x00\x01\x01\x01\xb7\x00\x03\x01\x04\x01\x6e\x00\x06\x01\x07\x01\x08\x01\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x64\x00\x61\x00\x0f\x01\x10\x01\x11\x01\x71\x00\x0c\x00\x12\x01\x13\x01\x14\x01\x15\x01\x33\x00\x49\x00\x19\x00\x1b\x01\x5b\x00\x1b\x01\x50\x00\x1d\x01\x1e\x01\x72\x00\x72\x00\x21\x01\x73\x00\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x64\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\x6c\x00\x6c\x00\x6c\x00\xb4\x00\x6c\x00\x72\x00\xb7\x00\x39\x00\x68\x00\xba\x00\xbb\x00\x72\x00\x51\x00\x56\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x72\x00\x17\x00\x4f\x00\x72\x00\x50\x00\x00\x01\x01\x01\x6c\x00\x64\x00\x04\x01\x54\x00\x06\x01\x6c\x00\x50\x00\x84\x00\x85\x00\x86\x00\x5a\x00\x4d\x00\x59\x00\x0f\x01\x8b\x00\x11\x01\x8d\x00\x5e\x00\x8f\x00\x90\x00\x91\x00\x72\x00\x51\x00\x4f\x00\x4d\x00\x1b\x01\x50\x00\x84\x00\x85\x00\x86\x00\x50\x00\x81\x00\x68\x00\xed\x00\xee\x00\x5b\x00\x5c\x00\x4d\x00\x4d\x00\x6c\x00\x91\x00\x61\x00\x73\x00\xf7\x00\xf8\x00\x6c\x00\x54\x00\xfb\x00\xfc\x00\x72\x00\x39\x00\x73\x00\x50\x00\x5a\x00\x19\x00\xff\x00\x00\x01\x01\x01\xb7\x00\x73\x00\x04\x01\x50\x00\x06\x01\x77\x00\x78\x00\x6c\x00\x19\x00\x7b\x00\x7c\x00\x51\x00\x12\x01\x13\x01\x14\x01\x15\x01\x76\x00\x1a\x00\x80\x00\x80\x00\xb7\x00\x1b\x01\x4d\x00\x1d\x01\x1e\x01\x4d\x00\x4d\x00\x21\x01\x16\x00\x5e\x00\x0c\x00\x91\x00\x71\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x80\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xff\x00\x00\x01\x01\x01\xb4\x00\x6b\x00\x04\x01\xb7\x00\x06\x01\x4d\x00\xba\x00\xbb\x00\x4d\x00\x68\x00\x19\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf4\x00\xf5\x00\x64\x00\x72\x00\x50\x00\xf9\x00\x73\x00\xfb\x00\xfc\x00\x54\x00\x50\x00\x00\x01\x01\x01\x50\x00\x03\x01\x04\x01\x50\x00\x06\x01\x07\x01\x08\x01\x72\x00\x51\x00\x19\x00\x61\x00\x19\x00\x56\x00\x0f\x01\x10\x01\x11\x01\x07\x00\x12\x01\x00\x01\x01\x01\x15\x01\x51\x00\x04\x01\x49\x00\x06\x01\x1b\x01\x1b\x01\xed\x00\xee\x00\x1e\x01\x4d\x00\x54\x00\x68\x00\x0f\x01\x7d\x00\x11\x01\x61\x00\xf7\x00\xf8\x00\x50\x00\xb4\x00\xfb\x00\xfc\x00\xb7\x00\x56\x00\x1b\x01\xba\x00\xbb\x00\x71\x00\x71\x00\x81\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x64\x00\x54\x00\x6c\x00\x6c\x00\x6b\x00\x8a\x00\x52\x00\x12\x01\x13\x01\x14\x01\x15\x01\x68\x00\x19\x00\x19\x00\x6c\x00\x8a\x00\x1b\x01\x89\x00\x1d\x01\x1e\x01\x6c\x00\x71\x00\x21\x01\x5b\x00\x2d\x00\x84\x00\x85\x00\x86\x00\x27\x01\x28\x01\x29\x01\x2a\x01\x8b\x00\x71\x00\x8d\x00\x51\x00\x8f\x00\x90\x00\x91\x00\x72\x00\xed\x00\xee\x00\x4d\x00\x52\x00\x4d\x00\x19\x00\x07\x00\x89\x00\x07\x00\x19\x00\xf7\x00\xf8\x00\x50\x00\x61\x00\xfb\x00\xfc\x00\x84\x00\x85\x00\x86\x00\x68\x00\x4d\x00\x89\x00\x80\x00\x8b\x00\x71\x00\x8d\x00\x02\x00\x8f\x00\x90\x00\x91\x00\x4d\x00\x52\x00\x19\x00\x4d\x00\x4d\x00\x19\x00\xb7\x00\x12\x01\x13\x01\x14\x01\x15\x01\x50\x00\x47\x00\x23\x00\x56\x00\x1a\x00\x1b\x01\x07\x00\x1d\x01\x1e\x01\x19\x00\x54\x00\x21\x01\x84\x00\x85\x00\x86\x00\x09\x00\x81\x00\x89\x00\x6c\x00\x8b\x00\x6b\x00\x8d\x00\x67\x00\x8f\x00\x90\x00\x91\x00\xb7\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\x6b\x00\xf5\x00\x4f\x00\x2e\x00\x54\x00\xf9\x00\x8a\x00\xfb\x00\xfc\x00\x84\x00\x85\x00\x86\x00\x50\x00\x71\x00\x89\x00\x71\x00\x8b\x00\x64\x00\x8d\x00\x64\x00\x8f\x00\x90\x00\x91\x00\x6b\x00\x64\x00\x50\x00\x6c\x00\x72\x00\x8a\x00\x6c\x00\x12\x01\x61\x00\xb7\x00\x15\x01\x5a\x00\x8a\x00\x81\x00\x00\x01\x01\x01\x1b\x01\x03\x01\x04\x01\x1e\x01\x06\x01\x07\x01\x08\x01\x02\x00\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x72\x00\x0f\x01\x10\x01\x11\x01\x4d\x00\x6c\x00\x72\x00\x6b\x00\x89\x00\xb7\x00\x54\x00\x19\x00\x54\x00\x1b\x01\x84\x00\x85\x00\x86\x00\x00\x01\x01\x01\x07\x00\x03\x01\x04\x01\x6c\x00\x06\x01\x07\x01\x08\x01\x6c\x00\x91\x00\x07\x00\x50\x00\x19\x00\x19\x00\x0f\x01\x10\x01\x11\x01\x77\x00\x84\x00\x85\x00\x86\x00\x87\x00\x4f\x00\x89\x00\x77\x00\x8b\x00\x1b\x01\x8d\x00\x8a\x00\x8f\x00\x90\x00\x91\x00\x30\x00\x52\x00\x85\x00\xc7\x00\x00\x01\x01\x01\xe3\x00\x03\x01\x04\x01\x24\x01\x06\x01\x07\x01\x08\x01\xe3\x00\x38\x00\xb7\x00\x53\x00\xe3\x00\x41\x00\x0f\x01\x10\x01\x11\x01\x79\x00\x42\x00\x31\x00\x22\x01\x32\x00\x23\x01\x23\x01\x7a\x00\x06\x01\x1b\x01\x00\x01\x01\x01\x76\x00\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\x76\x00\x7a\x00\x99\x00\x53\x00\x7f\x00\xc5\x00\x0f\x01\x10\x01\x11\x01\x24\x01\x84\x00\x85\x00\x86\x00\xbd\x00\x22\x01\x89\x00\x16\x00\x8b\x00\x1b\x01\x8d\x00\x16\x00\x8f\x00\x90\x00\x91\x00\x30\x00\x03\x00\xd6\x00\x23\x01\x84\x00\x85\x00\x86\x00\x87\x00\x23\x01\x89\x00\xd6\x00\x8b\x00\xde\x00\x8d\x00\x62\x00\x8f\x00\x90\x00\x91\x00\x22\x01\x4f\x00\x7e\x00\x95\x00\x96\x00\x00\x01\x01\x01\x22\x01\xed\x00\x04\x01\x28\x01\x06\x01\x22\x01\x41\x00\x66\x00\x22\x01\x28\x01\x50\x00\x6f\x00\xb7\x00\x0f\x01\x6c\x00\x11\x01\x77\x00\x34\x00\x16\x00\x16\x00\x00\x01\x01\x01\x2c\x00\x03\x01\x04\x01\x1b\x01\x06\x01\x07\x01\x08\x01\x76\x00\xb7\x00\x20\x00\x4f\x00\x20\x00\x33\x00\x0f\x01\x10\x01\x11\x01\x76\x00\x56\x00\x5d\x00\x58\x00\x59\x00\x43\x00\x5b\x00\x19\x01\x1a\x01\x1b\x01\x1c\x01\x58\x00\x6a\x00\x1f\x01\x20\x01\x1e\x01\x61\x00\x65\x00\x24\x01\x84\x00\x85\x00\x86\x00\x87\x00\x6c\x00\x89\x00\x2c\x00\x8b\x00\x9e\x00\x8d\x00\x72\x00\x8f\x00\x90\x00\x91\x00\x22\x01\x77\x00\x78\x00\x7e\x00\x0e\x00\x7b\x00\x7c\x00\x20\x00\x20\x00\x9e\x00\xbd\x00\xac\x00\x42\x00\xed\x00\x00\x01\x01\x01\x9c\x00\x03\x01\x04\x01\x46\x00\x06\x01\x07\x01\x08\x01\x23\x01\x17\x00\x17\x00\x35\x00\x47\x00\x53\x00\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\x22\x01\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\x1b\x01\x22\x01\x4b\x00\xa5\x00\x6a\x00\xde\x00\x0f\x01\x10\x01\x11\x01\x22\x01\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x00\x89\x00\x1c\x00\x8b\x00\x1b\x01\x8d\x00\x26\x00\x8f\x00\x90\x00\x91\x00\x80\x00\x81\x00\x0b\x00\x24\x01\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x23\x01\x8b\x00\x8c\x00\x8d\x00\x23\x01\x8f\x00\x90\x00\x91\x00\x28\x01\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\x22\x01\xf5\x00\xed\x00\x51\x00\x23\x01\xf9\x00\x22\x01\xfb\x00\xfc\x00\x23\x01\x22\x01\x4f\x00\x22\x01\xb7\x00\x22\x01\x28\x01\x51\x00\x20\x00\x16\x00\x16\x00\x20\x00\x00\x01\x01\x01\x9e\x00\x03\x01\x04\x01\x17\x00\x06\x01\x07\x01\x08\x01\x12\x01\xb7\x00\x23\x01\x15\x01\x23\x01\x23\x01\x0f\x01\x10\x01\x11\x01\x1b\x01\x17\x00\xff\xff\x1e\x01\x23\x01\xff\xff\x80\x00\xff\xff\xff\xff\x1b\x01\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x24\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf2\x00\xf3\x00\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xf9\x00\xff\xff\xfb\x00\xfc\x00\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\x12\x01\x03\x01\x04\x01\x15\x01\x06\x01\x07\x01\x08\x01\x1b\x01\xff\xff\x1b\x01\xff\xff\xff\xff\x1e\x01\x0f\x01\x10\x01\x11\x01\x24\x01\x80\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1b\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\xff\xff\xff\x00\x00\x01\x01\x01\xff\xff\xff\xff\x04\x01\xff\xff\x06\x01\x80\x00\xff\xff\xff\xff\xed\x00\x84\x00\x85\x00\x86\x00\x87\x00\x0f\x01\x89\x00\x11\x01\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\xff\xff\x1b\x01\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x80\x00\xff\xff\xff\xff\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x1b\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xb7\x00\x8f\x00\x90\x00\x91\x00\x80\x00\xff\xff\xff\xff\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\x13\x01\x14\x01\x15\x01\xff\xff\xb7\x00\x0f\x01\x10\x01\x11\x01\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x84\x00\x85\x00\x86\x00\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x80\x00\xff\xff\xff\xff\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x1b\x01\x89\x00\xb7\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x80\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xb7\x00\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x00\x01\x01\x01\xff\xff\xff\xff\x04\x01\xff\xff\x06\x01\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\x0f\x01\xff\xff\x11\x01\x00\x01\x01\x01\x56\x00\xff\xff\x04\x01\xff\xff\x06\x01\x5b\x00\x5c\x00\x1b\x01\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x0f\x01\xff\xff\x11\x01\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6c\x00\xff\xff\xed\x00\x1b\x01\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x0f\x01\x10\x01\x11\x01\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x81\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x81\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xed\x00\x81\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xb7\x00\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\x81\x00\x1b\x01\x61\x00\x84\x00\x85\x00\x86\x00\xfe\x00\x88\x00\x89\x00\xff\xff\xb7\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x0b\x01\x73\x00\x0d\x01\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x16\x01\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x1c\x01\xff\xff\xff\xff\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xb7\x00\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xed\x00\x00\x01\x01\x01\x95\x00\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xb7\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xed\x00\x81\x00\x1b\x01\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xed\x00\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x02\x00\x13\x01\x14\x01\x15\x01\xff\xff\x0f\x01\x10\x01\x11\x01\x0a\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\x1b\x01\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x1b\x01\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\xff\xff\x14\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x75\x00\x76\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x4f\x00\x50\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x5b\x00\x5c\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x52\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\x58\x00\x7b\x00\x7c\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\x14\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x4f\x00\x50\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x5b\x00\x5c\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x52\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\x58\x00\x7b\x00\x7c\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x4f\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x5b\x00\x5c\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x52\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\x58\x00\x7b\x00\x7c\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\x14\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\x73\x00\x5b\x00\x5c\x00\xff\xff\x77\x00\x78\x00\xff\xff\x61\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x4f\x00\xff\xff\x51\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\x61\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\x4f\x00\xff\xff\x73\x00\x52\x00\xff\xff\x54\x00\x77\x00\x78\x00\xff\xff\x58\x00\x7b\x00\x7c\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xfe\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0b\x01\xff\xff\x0d\x01\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x1c\x01\xff\xff\xff\xff\x1f\x01\x20\x01\xff\xff\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xfe\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0b\x01\xff\xff\x0d\x01\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x1c\x01\xff\xff\xff\xff\x1f\x01\x20\x01\xff\xff\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xfe\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0b\x01\xff\xff\x0d\x01\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x1c\x01\xff\xff\xff\xff\x1f\x01\x20\x01\xff\xff\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x52\x00\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x1b\x01\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf6\x00\x3b\x00\xf8\x00\x3d\x00\xff\xff\xfb\x00\xff\xff\xff\xff\xfe\x00\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\x0a\x01\x8f\x00\x90\x00\x91\x00\x52\x00\x93\x00\xff\xff\xff\xff\x12\x01\xff\xff\x58\x00\x15\x01\xff\xff\x5b\x00\xff\xff\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\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\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\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\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\x70\x00\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\x58\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x75\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xf9\x00\xff\xff\xfb\x00\xfc\x00\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\xff\xff\x12\x01\xff\xff\xff\xff\x15\x01\xff\xff\xff\xff\xff\xff\x19\x01\x1a\x01\x1b\x01\x1c\x01\xff\xff\x1e\x01\xff\xff\x20\x01\x67\x00\xff\xff\x69\x00\x24\x01\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xed\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\x59\x00\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x40\x00\x41\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\x6e\x00\xb7\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x58\x00\x89\x00\xff\xff\x8b\x00\x5c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x63\x00\x94\x00\x95\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\x1b\x01\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\xff\xff\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xb7\x00\xff\xff\x9d\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1b\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\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\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xb7\x00\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\x84\x00\x85\x00\x86\x00\x87\x00\xb7\x00\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1b\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x9d\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xb7\x00\xff\xff\x9d\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1b\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x98\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1b\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\x84\x00\x85\x00\x86\x00\x87\x00\xb7\x00\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xb7\x00\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\xb7\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xed\x00\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xed\x00\xb7\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xed\x00\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1b\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xb7\x00\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xc3\x00\xc4\x00\xff\xff\xc6\x00\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1b\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xb7\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\x84\x00\x85\x00\x86\x00\xb7\x00\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xb7\x00\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1b\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\x84\x00\x85\x00\x86\x00\xb7\x00\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\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\xed\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x1b\x01\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\xff\xff\x00\x01\x01\x01\x02\x00\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\x10\x01\x11\x01\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x01\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x80\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\x6b\x00\xff\xff\xff\xff\x02\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x75\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x02\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x02\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x75\x00\x76\x00\x77\x00\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x02\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x80\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x02\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\x73\x00\xff\xff\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x01\x00\x02\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\x73\x00\xff\xff\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\xff\xff\x7c\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x13\x00\x79\x00\x7a\x00\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x02\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\x0a\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x16\x00\xff\xff\x7a\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x0a\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x16\x00\xff\xff\x7a\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\x16\x00\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\xff\xff\x04\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\xff\xff\xff\xff\x1a\x00\x79\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\xff\xff\xff\xff\x1a\x00\x79\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\x6b\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\x75\x00\xff\xff\xff\xff\x1a\x00\x79\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x4f\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x02\x00\xff\xff\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\x0a\x00\xff\xff\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\x77\x00\x78\x00\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x75\x00\x76\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\x76\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\x76\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\x76\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x0a\x00\xff\xff\xff\xff\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x63\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x72\x00\xff\xff\x2c\x00\x75\x00\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0a\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\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x02\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x75\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x75\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x02\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x56\x00\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\x6b\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\x75\x00\xff\xff\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xff\xff\xff\xff\x24\x01\xff\xff\x26\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xff\xff\xff\xff\x24\x01\xff\xff\x26\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xff\xff\xff\xff\x24\x01\xff\xff\x26\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\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\xd7\x00\xd8\x00\xd9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\x13\x01\x14\x01\x15\x01\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xcc\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xcc\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\xff\xff\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcf\x00\xd0\x00\xd1\x00\xd2\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\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xd0\x00\xd1\x00\xd2\x00\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xe5\x00\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xe4\x00\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xe4\x00\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xd4\x00\xd5\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xd7\x00\xd8\x00\xd9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xd4\x00\xd5\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xd7\x00\xd8\x00\xd9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xdc\x00\xdd\x00\xde\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xd2\x00\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xd9\x00\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\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\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xf7\x00\xf8\x00\xbb\x00\xff\xff\xfb\x00\xfc\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xe1\x00\xe2\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xe1\x00\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xed\x00\xee\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xed\x00\xee\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xed\x00\xee\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xed\x00\xee\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xed\x00\xee\x00\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xed\x00\xee\x00\x21\x01\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\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\x13\x01\x14\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x01\xff\xff\x1d\x01\x1e\x01\xff\xff\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--happyTable :: HappyAddr-happyTable = HappyA# "\x00\x00\x6e\x00\x81\x05\x9c\x02\x3f\x05\x40\x05\xa6\x04\x9e\x04\x83\x05\x5b\x04\x99\x04\x96\x04\x95\x04\x96\x04\x97\x04\x0d\x01\x97\x04\x0e\x01\x6b\x03\x23\x05\x3c\x05\x3d\x05\x97\x04\x0f\x01\x10\x01\x11\x01\x2c\x00\x2d\x00\x0a\x04\x12\x01\x19\x02\x1a\x02\x1b\x02\x59\x05\x2e\x00\x85\x05\x2f\x00\x30\x03\x86\x05\xb7\x04\x1a\x02\x1b\x02\xb6\x04\x1a\x02\xdb\x03\x1f\x05\xb7\x04\x1a\x02\x1b\x02\xb7\x04\x1a\x02\x1b\x02\x8b\x05\x3c\x03\x9b\x04\x9c\x04\x9d\x04\x9e\x04\x62\x05\x9c\x04\x9d\x04\x9e\x04\x49\x03\x66\x05\x9c\x04\x9d\x04\x9e\x04\xc1\xff\xf8\x02\x7e\x05\x7f\x05\x9e\x04\x3e\x03\x26\x04\x2f\x05\x9e\x04\x90\x02\x91\x02\x24\x05\x9e\x04\x58\x04\x79\x04\x7a\x04\x42\x03\x43\x03\xc1\xff\x53\x03\xf9\x04\x17\x02\xd0\x04\xcc\x04\xcd\x04\xf5\x04\x17\x02\xf2\x01\xf3\x01\xf4\x01\x88\x02\x17\x02\x90\x02\x91\x02\x68\x02\x6c\x03\x99\x04\x99\x03\x17\x02\x90\x03\x17\x02\x76\x05\x57\x01\xf9\x01\xfa\x01\x0b\x04\x6f\x03\xd1\xfc\x7f\x00\x65\x03\x5a\x05\xc1\xff\x99\x04\xf5\x02\xa7\x04\x6c\x01\x36\x01\x71\x00\x23\x01\xa8\x04\xa9\x04\x33\x05\x34\x05\x35\x05\x36\x05\xa9\x04\xbc\x02\x0d\x01\x80\x05\x36\x05\xa9\x04\x33\x04\x34\x04\x9b\xfe\x0a\x03\x7f\x00\x9b\xfe\x6a\x01\x69\x03\x77\x05\x14\x01\x16\x01\x9d\xfe\x6b\x01\x3a\x04\x33\x00\x7b\x01\x4c\xfe\xa0\x02\x89\x00\x36\x00\x08\x01\x26\x01\x8c\x00\x17\x02\xff\xff\x58\x01\x54\x04\x34\x04\x2c\x01\x2d\x01\x15\x01\x69\x02\x07\x01\x22\x01\x34\x00\x71\x00\x23\x01\xdd\x02\x3b\x04\x0b\x03\xf7\x02\x6c\x01\xce\x04\x71\x00\x23\x01\x89\x00\xbd\x02\x33\x00\x89\x02\x33\x00\x8a\x02\xf6\x04\x18\x02\x07\x01\xfb\x01\x89\x02\x4b\x00\x18\x02\x24\x01\x08\x01\x9d\x02\x25\x01\x18\x02\x19\x02\x54\x03\x33\x00\x4c\x00\x11\x00\xb6\x03\x18\x02\x26\x01\x18\x02\x9e\x02\x9f\x02\x44\x03\xf5\x01\x5c\x04\x25\x01\x26\x01\x93\x02\x88\x03\x7b\x04\x86\x03\x11\x00\xf5\x01\x34\x01\x4c\x00\xf5\x01\xdc\x01\x78\x00\xf6\x01\x79\x00\xfb\x01\xcf\x04\x4b\x00\xa0\x02\x44\x03\xf5\x01\x2d\x04\x25\x01\x3d\x03\x79\x01\x92\x02\x6d\x03\x4c\x00\x11\x00\x11\x00\xf5\x01\x21\x02\xd1\xfc\x6f\x00\x70\x00\xf5\x01\x6d\x03\x71\x00\x72\x00\xf9\x02\x73\x00\x6d\x03\x5c\x04\xf9\x02\x19\x02\x11\x00\x2a\x01\x2b\x01\x18\x02\x11\x00\x3d\x03\x9f\x04\x4c\x00\xa0\x04\xa1\x04\x74\x00\x11\x00\x6e\x05\xa9\x02\xdd\x04\x62\x03\x0e\x00\x0f\x00\x10\x00\x75\x00\x3e\x05\x76\x00\x77\x00\x78\x00\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x41\x05\xfa\x04\xce\x03\x41\x05\x30\x00\x17\x02\x30\x00\x30\x00\x0c\x02\x3e\x05\x07\x01\x4c\x00\x30\x00\x35\x04\x30\x00\x1c\x02\x30\x00\x2e\x01\x2f\x01\x11\x00\x27\x02\x56\x00\x92\x04\xf4\x01\x1c\x02\x58\x00\x9f\x04\x1c\x02\xa0\x04\xa1\x04\x9f\x04\x1c\x02\xa0\x04\xa1\x04\x1c\x02\x9f\x04\x8d\x03\xa0\x04\xa1\x04\x35\x04\x9f\x04\x0d\x02\xa0\x04\xa1\x04\x9f\x04\x11\x00\xa0\x04\xa1\x04\x9f\x04\x51\x05\xa0\x04\xa1\x04\xaa\x04\xc1\xff\xab\x04\x17\x02\x46\x00\xaa\x04\x63\x03\xab\x04\xbc\xff\x46\x00\xaa\x04\x17\x02\xab\x04\xb5\x03\x46\x00\x4e\x03\x4f\x03\xac\x04\x0f\x00\x10\x00\x25\x02\xfa\x01\xac\x04\x0f\x00\x10\x00\x11\x00\xb6\x03\xac\x04\x0f\x00\x10\x00\x11\x00\x4f\x01\xcc\x00\x48\x01\xc1\xff\x11\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\x35\x01\x36\x01\x71\x00\x23\x01\x44\x03\x23\x03\x24\x03\x25\x01\x71\x03\x2c\x01\x2d\x01\x17\x02\xe7\x00\x11\x00\x22\x01\x18\x02\x71\x00\x23\x01\x8c\x03\xe8\x00\xe9\x00\xf5\x01\x49\x01\x4a\x01\xea\x00\x33\x00\xd3\x04\x7b\x04\x37\x01\xcd\x00\x87\x03\xba\x04\x17\x02\xb9\x02\x11\x00\x28\x02\x37\x03\x26\x01\x25\x01\x24\x01\x3b\x01\x32\x00\x25\x01\x88\x03\x11\x00\x8d\x03\xfa\x01\xbe\x01\x11\x00\x06\x03\xbc\xff\x26\x01\x8d\x03\x30\x01\x2d\x01\xeb\x00\x3c\x01\xf5\x01\x22\x01\x72\x03\x71\x00\x23\x01\xcc\x00\xf6\x01\xbb\x04\x18\x02\x94\x03\xe4\x00\xe5\x00\xe6\x00\x50\x05\x01\x03\x28\x02\x18\x02\xba\x02\x25\x01\xfb\x01\x38\x03\x4b\x00\x33\x00\xff\xff\x11\x00\xe7\x00\x24\x01\xb6\x04\x07\x03\x25\x01\x90\x03\x4c\x00\xe8\x00\xe9\x00\x9d\xfe\x11\x00\x68\x01\xea\x00\x26\x01\x14\x01\x9f\x01\xbe\x01\xcd\x00\xfb\x01\x6b\x01\x4b\x00\x65\x03\xfa\x01\x82\x02\x07\x02\x02\x03\xec\x00\xed\x00\xee\x00\x83\x02\x4c\x00\x18\x02\xbd\x03\xef\x00\x15\x01\xcc\x02\x8c\x00\x3c\x02\x50\x01\xf0\x00\xd0\x00\x6b\x01\x88\x03\xeb\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\xcc\x00\x51\x01\x18\x02\x52\x01\xcb\x04\xcc\x04\xcd\x04\x08\x01\xff\xff\x84\x02\x36\x02\x04\x03\x75\x00\x5e\x05\x76\x00\x77\x00\x78\x00\x3d\x02\x79\x00\x5f\x04\x60\x04\x7c\x00\x7d\x00\x15\x05\xfa\x01\x7e\x02\x6c\x01\xce\x04\x71\x00\x23\x01\x01\x02\x7f\x02\xea\x00\xfb\x01\xd1\xfc\x4b\x00\x05\x03\xcd\x00\x37\x02\xf9\x01\x9c\x00\x9d\x00\x61\x04\x66\x04\x38\x02\x4c\x00\xec\x00\xed\x00\xee\x00\x85\x03\x9e\x00\x70\x00\x48\x01\xef\x00\x71\x00\x72\x00\x8c\x00\x07\x01\xdc\x04\xf0\x00\xd0\x00\x80\x02\x86\x03\x26\x01\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\xd2\x04\xdd\x04\x7f\x00\x4e\x05\xcc\x04\xcd\x04\x32\x03\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x49\x01\x4a\x01\xd3\x04\x80\x00\x81\x00\x11\x00\xf0\x04\x7a\x00\x7b\x00\x82\x00\xfb\x01\xa0\x00\x4b\x00\x6c\x01\xce\x04\x71\x00\x23\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x68\x01\x4c\x00\xb0\x01\xfc\x02\xfe\x01\x15\x01\xa2\x02\xfd\x02\x9c\x00\x9d\x00\x88\x00\x89\x00\xf6\x03\xb1\x01\xec\x00\xed\x00\xab\x02\x63\x04\x9e\x00\x70\x00\xef\x04\xef\x00\x71\x00\x72\x00\x8c\x00\x4f\x02\x8c\x02\xad\x02\xd0\x00\x26\x01\x6b\x01\x34\x02\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\xf5\x01\xcc\x00\x15\x01\xfb\x01\xf7\x03\x4b\x00\xcf\x04\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x6c\x01\x6d\x01\x71\x00\x23\x01\x4c\x00\x11\x00\x7f\x00\x7a\x00\x7b\x00\x5f\x04\x60\x04\xa0\x00\x6c\x01\xce\x04\x71\x00\x23\x01\x0a\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xb5\x04\xea\x00\x36\x00\x37\x00\x38\x00\x24\x02\xcd\x00\x4b\x00\x9c\x00\x9d\x00\x09\x02\x61\x04\x62\x04\xb6\x04\x6a\x01\x47\x05\x26\x01\x4c\x00\x9e\x00\x70\x00\x6b\x01\x33\x02\x71\x00\x72\x00\xf8\x01\x11\x02\x89\x00\x34\x02\x26\x01\x99\x02\x48\x00\x30\x01\x2d\x01\x5c\x02\x5d\x02\x5e\x02\x22\x01\xf5\x01\x71\x00\x23\x01\x12\x02\x13\x02\xe0\x01\xcf\x04\x46\x00\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x2d\x02\xf8\x04\x86\x04\x87\x04\x40\x00\x11\x00\xe1\x01\x7a\x00\x7b\x00\xe9\x01\x2e\x02\xa0\x00\x24\x01\x9d\x02\x88\x03\x25\x01\x4c\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x11\x00\xe4\x03\x5e\x02\x26\x01\xfa\x03\x9f\x02\x5f\x02\x0f\x00\x10\x00\x6c\x01\x76\x03\x71\x00\x23\x01\xff\xff\x11\x00\xec\x00\xed\x00\xab\x02\x63\x04\x5d\x05\xdc\x01\x78\x00\xef\x00\x79\x00\x7b\x05\x8c\x00\xcc\x00\xa0\x02\xad\x02\xd0\x00\x7c\x05\xa7\x01\x5e\x05\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\xfe\x04\xfc\x04\x80\x00\x81\x00\x5f\x02\x0f\x00\x10\x00\x26\x01\x82\x00\x00\x02\x80\x00\x81\x00\x11\x00\x9d\xfe\x48\x05\x1e\x03\x82\x00\x42\x00\x43\x00\xea\x00\x94\xfd\x45\x00\x08\x02\x46\x00\xcd\x00\x1a\x03\x1f\x03\x20\x03\xea\x02\xbe\x01\x88\x00\x8f\x04\x49\x00\xb2\x02\x4b\x00\x7f\x00\xc4\x01\x09\x02\x88\x00\x62\x00\x9c\x00\x9d\x00\x8b\x00\x65\x00\x4c\x00\x1b\x03\x1c\x03\x80\x00\x81\x00\xa0\x02\x9e\x00\x70\x00\x21\x01\x82\x00\x71\x00\x72\x00\x22\x01\x3f\x02\x71\x00\x23\x01\x36\x00\x37\x00\x38\x00\x11\x00\x6a\x01\xcf\x01\x7b\x00\xec\x02\x31\x05\x3d\x01\x6b\x01\x3d\x00\x3e\x00\x3f\x00\xf8\x03\x88\x00\x89\x00\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x24\x01\xce\x02\x09\x02\x25\x01\x3c\x04\x11\x00\x0f\x02\x7a\x00\x7b\x00\x11\x00\x10\x02\xa0\x00\x26\x01\x30\x05\x3d\x04\xf5\x01\xcb\x04\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x2a\x02\xec\x00\xed\x00\xab\x02\xac\x02\xf3\x03\x62\x00\x09\x02\xef\x00\x40\x00\x65\x00\x8c\x00\xcc\x00\xce\x02\xad\x02\xd0\x00\x55\x00\x78\x05\xc3\x01\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\x9b\x02\x60\x05\x79\x05\x57\x00\x26\x05\x13\x03\xd9\x02\xda\x02\x36\x00\x37\x00\x38\x00\x4c\x00\xea\x02\x27\x05\x99\x02\xff\xff\x80\x00\x81\x00\x6b\x01\xea\x00\xfe\x01\x3f\x00\x82\x00\x62\x00\xcd\x00\xd2\x01\x7d\x00\x65\x00\x3f\x02\xc2\x01\xd3\x01\x63\x00\x64\x00\xaa\x02\x11\x00\x66\x00\x67\x00\x40\x03\xb3\x02\xb0\x02\xb1\x02\x9d\x00\xb2\x01\x2b\x04\x88\x00\x28\x05\x25\x01\xaf\x01\x8b\x00\x29\x05\x9e\x00\x70\x00\x11\x00\xff\x03\x71\x00\x72\x00\x25\x01\x42\x00\x43\x00\x40\x00\x44\x00\x45\x00\x11\x00\x46\x00\x47\x00\x48\x00\x81\x01\x52\x02\x0e\x00\x0f\x00\x10\x00\x34\x02\x49\x00\x4a\x00\x4b\x00\x84\x01\x11\x00\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x83\x00\x07\x02\x05\x02\x4c\x00\x39\x01\x11\x00\x85\x00\x7a\x00\x7b\x00\x39\x02\xd1\xfc\xa0\x00\xff\xff\x34\x02\x1d\x04\x87\x00\x4b\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x41\x03\xec\x00\xed\x00\xab\x02\xac\x02\x4c\x00\x11\x00\x64\x02\xef\x00\xbc\x01\x53\x04\x8c\x00\xcc\x00\x07\x01\xad\x02\xd0\x00\x11\x00\x08\x05\x09\x05\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\xfb\x04\xfc\x04\x1d\xfd\x0f\x02\x69\x04\x42\x00\x43\x00\x10\x02\x44\x00\x45\x00\x2c\x03\x46\x00\x47\x00\x48\x00\x2d\x03\x75\x01\x0f\x00\x10\x00\x79\x01\xea\x00\x49\x00\x4a\x00\x4b\x00\x11\x00\xcd\x00\x6a\x04\x70\x04\x88\x01\xff\xff\x89\x01\x83\x00\x8a\x01\x4c\x00\x8b\x01\x2b\x05\x4c\x01\x85\x00\x34\x01\xaf\x02\xb0\x02\xb1\x02\x9d\x00\x62\x00\x29\x05\x70\x00\x87\x00\x65\x00\x71\x00\x72\x00\x8a\x00\x9e\x00\x70\x00\xf5\x01\x83\x00\x71\x00\x72\x00\x4b\x01\x39\x01\xc7\x04\x85\x00\x36\x00\x37\x00\x38\x00\x41\x02\x78\x00\x1e\x01\x79\x00\xec\x02\x87\x00\x3d\x01\xbe\x02\x3d\x00\x3e\x00\x3f\x00\xd3\x01\x23\x03\x24\x03\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x7a\x00\x7b\x00\x28\x03\xce\x01\x10\x00\x11\x00\x29\x03\x7a\x00\x7b\x00\xff\xff\x11\x00\xa0\x00\xcf\x01\x7b\x00\xd8\x02\xd9\x02\xda\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x1b\x01\xec\x00\xed\x00\xab\x02\x6c\x04\xb5\x01\x0f\x02\xb6\x01\xef\x00\x40\x00\x10\x02\x8c\x00\xcc\x00\x7f\x00\xad\x02\xd0\x00\x5a\x03\x5b\x03\x5c\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\x80\x00\x81\x00\xe8\x02\xff\xff\x69\x04\x45\x00\x82\x00\x46\x00\xd1\x01\x9f\x01\x78\x00\x07\x01\x79\x00\x09\x01\x0a\x01\xd2\x01\x7d\x00\x6a\x01\xbe\x02\xea\x00\xd3\x01\x19\x01\xd3\x01\x6b\x01\xcd\x00\x6a\x04\x6b\x04\xff\xff\x88\x00\x89\x00\x18\x01\xa2\x02\x8b\x00\x8c\x00\x36\x00\x37\x00\x38\x00\x1e\x03\xa3\x02\xa4\x02\x9c\x00\x9d\x00\xa5\x02\xa6\x02\xde\x03\x3d\x00\x3e\x00\x3f\x00\xdf\x03\xde\x03\x9e\x00\x70\x00\xde\x03\x93\x04\x71\x00\x72\x00\x4b\x05\x42\x00\x43\x00\x15\x03\x44\x00\x45\x00\xde\x03\x46\x00\x47\x00\x48\x00\x46\x05\x1e\x01\x0f\x00\x10\x00\x23\x03\x24\x03\x49\x00\x4a\x00\x4b\x00\x11\x00\x15\x02\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x08\x05\x57\x05\xde\x03\x4c\x00\x40\x00\x11\x00\x8a\x05\x7a\x00\x7b\x00\x41\x02\x78\x00\xa0\x00\x79\x00\x1c\x01\x0f\x00\x10\x00\x13\x03\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x11\x00\xec\x00\xed\x00\xab\x02\x6c\x04\xba\x02\x0f\x00\x10\x00\xef\x00\x04\x02\x05\x02\x8c\x00\xcc\x00\x11\x00\xad\x02\xd0\x00\x4f\x03\x50\x03\x51\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\x7f\x01\xeb\x02\x80\x01\xb7\x02\x0f\x00\x10\x00\x5f\x04\x60\x04\x36\x00\x37\x00\x38\x00\x11\x00\xa7\x02\x11\x03\x16\x05\x36\x00\x37\x00\x38\x00\x17\x05\xea\x00\xdc\x02\x18\x05\x17\x03\xdd\x02\xcd\x00\x6f\x05\x62\x00\xa3\xfe\x18\x05\x01\x05\xa3\xfe\x42\x00\x43\x00\x08\x03\x44\x00\x45\x00\x00\x03\x46\x00\x47\x00\x48\x00\x9c\x00\x9d\x00\x19\x05\x0e\x04\x0f\x04\x10\x04\x49\x00\x4a\x00\x4b\x00\x70\x05\x9e\x00\x70\x00\x7b\x01\x77\x01\x71\x00\x72\x00\x7c\x01\xb8\x01\x4c\x00\x40\x00\x36\x00\x37\x00\x38\x00\x11\x03\x85\x01\x43\x00\x40\x00\xec\x02\x45\x00\x3d\x01\x46\x00\x3d\x00\x3e\x00\x3f\x00\xc5\x02\x10\x00\xf8\x02\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x11\x00\x2b\x05\xcf\x01\x7b\x00\x45\x00\x11\x00\x46\x00\x7a\x00\x7b\x00\xee\x02\xb5\x01\xa0\x00\xb6\x01\xb4\x02\x0f\x00\x10\x00\x00\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x11\x00\xec\x00\xed\x00\xab\x02\x63\x04\x7c\x04\x0f\x04\x10\x04\xef\x00\x40\x00\xe7\x02\x8c\x00\xcc\x00\xe6\x02\xad\x02\xd0\x00\x76\x04\x0f\x04\x10\x04\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\xc8\x04\xc9\x04\x46\x00\xe5\x02\x69\x04\x42\x00\x43\x00\xe3\x02\x90\x01\x45\x00\x91\x01\x46\x00\x42\x00\x43\x00\xe4\x02\x7f\x01\x45\x00\x80\x01\x46\x00\xea\x00\x49\x00\x78\x02\x4b\x00\x79\x02\xcd\x00\x09\x05\x24\x04\x49\x00\x25\x04\x4b\x00\xe0\x02\xd6\x01\x4c\x00\xd7\x01\xde\x02\x1c\x04\xd8\x01\x1d\x04\x58\x01\x4c\x00\x9c\x00\x9d\x00\x0f\x03\x85\x01\x43\x00\xcf\x02\x7f\x01\x45\x00\x80\x01\x46\x00\x9e\x00\x70\x00\x79\x01\x77\x01\x71\x00\x72\x00\xce\x02\x42\x00\x43\x00\xdb\x01\x44\x00\x45\x00\x25\x01\x46\x00\x47\x00\x48\x00\xcb\x02\xda\x03\x11\x00\xdb\x03\x7a\x00\x7b\x00\x49\x00\x4a\x00\x4b\x00\x7c\x01\x7d\x01\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x8b\x04\x8c\x04\x8d\x04\x4c\x00\xbc\x01\x11\x00\x51\x02\x7a\x00\x7b\x00\x31\x01\x32\x01\xa0\x00\xdd\x04\x43\x01\x44\x01\x45\x01\x46\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xc9\x02\xec\x00\xed\x00\xab\x02\x6c\x04\xd1\x01\x9f\x01\x78\x00\xef\x00\x79\x00\x09\xfd\x8c\x00\xcc\x00\x50\x02\xad\x02\xd0\x00\xc4\x04\x0f\x04\x10\x04\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\x75\x04\xd3\x04\x76\x04\x7f\x00\x54\x01\xb8\xfe\x76\x01\x77\x01\xb8\xfe\xf0\x02\xf1\x02\xf2\x02\xf3\x02\xf4\x02\xc5\x02\x80\x00\x81\x00\xc4\x02\x57\x04\xea\x00\x58\x04\x82\x00\xfd\x02\xfe\x02\xcd\x00\x36\x00\x37\x00\x38\x00\x69\x05\x0f\x04\x10\x04\xc2\x02\xec\x02\xe6\x04\x3d\x01\xc1\x02\x3d\x00\x3e\x00\x3f\x00\x55\x01\x9c\x00\x9d\x00\x6d\x02\x88\x00\x89\x00\x73\x03\x74\x03\x8b\x00\x8c\x00\xc0\x02\x9e\x00\x70\x00\x7c\x01\x17\x04\x71\x00\x72\x00\x8c\x05\x0f\x04\x10\x04\xf2\x01\x36\x00\x37\x00\x38\x00\x0e\x03\x85\x01\x43\x00\xf0\x01\xd4\x04\x45\x00\x3d\x01\x46\x00\x3d\x00\x3e\x00\x3f\x00\x99\x02\x48\x00\x40\x00\xd1\x00\x9f\x00\x0f\x00\xd2\x00\xd1\x01\x9f\x01\x78\x00\x98\x02\x79\x00\x11\x00\x97\x02\x7a\x00\x7b\x00\x96\x02\xed\x04\xa0\x00\xee\x04\xe2\x04\xa5\x04\xe3\x04\xa6\x04\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x95\x02\xec\x00\xed\x00\xab\x02\xac\x02\xed\x04\x90\x02\xee\x04\xef\x00\x40\x00\x8e\x02\x8c\x00\xcc\x00\x88\x02\xad\x02\xd0\x00\x03\x04\x04\x04\x85\x02\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\x77\x03\x85\x01\x43\x00\x67\x04\x5c\x03\x45\x00\x7c\x02\x46\x00\x36\x00\x37\x00\x38\x00\xf2\x04\xf3\x04\x81\x02\x7d\x02\x7c\x02\x75\x02\x74\x02\x71\x05\xea\x00\x73\x02\x18\x05\x42\x00\x43\x00\xcd\x00\x44\x00\x45\x00\x72\x02\x46\x00\x47\x00\x48\x00\x6e\x02\x6d\x02\xe5\x04\x6c\x02\xbe\x01\x64\x02\x49\x00\x4a\x00\x4b\x00\x9c\x00\x9d\x00\x54\x02\x53\x02\x51\x02\x50\x02\x4e\x02\x4d\x02\x3f\x02\x4c\x00\x9e\x00\x70\x00\x3b\x02\x2f\x02\x71\x00\x72\x00\x3e\x02\x42\x00\x43\x00\x40\x00\x44\x00\x45\x00\x3a\x02\x46\x00\x47\x00\x48\x00\x35\x02\x32\x02\x31\x02\x30\x02\x2c\x02\x27\x02\x49\x00\x4a\x00\x4b\x00\x15\x02\x0d\x01\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x07\x02\x05\x05\xd2\x03\x4c\x00\xd1\x03\x11\x00\xd0\x03\x7a\x00\x7b\x00\xcd\x03\xc4\x03\xa0\x00\xc5\x03\xc3\x03\xec\xfc\x08\xfd\xf4\xfc\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xc1\x03\xec\x00\xed\x00\xab\x02\xac\x02\xf3\xfc\x07\xfd\xed\xfc\xef\x00\xee\xfc\x3d\x02\x8c\x00\xcc\x00\xc2\x03\xad\x02\xd0\x00\xc0\x03\xbf\x03\xbc\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\xbb\x03\xba\x03\xb3\x03\x6b\x01\xa9\x03\x42\x00\x43\x00\x35\x02\x93\x03\x45\x00\xc8\x02\x46\x00\x31\x02\x8f\x03\x36\x00\x37\x00\x38\x00\x91\x03\x84\x03\xea\x00\x49\x00\xec\x02\x4b\x00\x3d\x01\xcd\x00\x3d\x00\x3e\x00\x3f\x00\x92\x03\x89\x03\x7f\x00\x83\x03\x4c\x00\x82\x03\x36\x00\x37\x00\x38\x00\x7f\x03\x81\x03\x80\x03\x9c\x00\x9d\x00\x80\x00\x81\x00\x7e\x03\x79\x03\x7d\x03\x02\x02\x82\x00\x76\x03\x9e\x00\x70\x00\x7c\x03\x68\x01\x71\x00\x72\x00\x1c\xfd\xcc\x00\x6b\x03\x67\x03\x6a\x03\x5f\x03\x40\x04\x85\x01\x43\x00\x40\x00\x55\x01\x45\x00\x5a\x03\x46\x00\x88\x00\x89\x00\x58\x03\x56\x03\x8b\x00\x8c\x00\x4c\x03\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x87\x00\x3a\x03\x34\x01\x35\x03\x40\x00\x11\x00\x2f\x03\x7a\x00\x7b\x00\x2e\x03\x2b\x03\xa0\x00\x27\x03\xcd\x00\x0d\x01\x8f\x02\xfa\x03\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x43\x04\xec\x00\xed\x00\xab\x02\x02\x04\x3e\x04\x85\x01\x43\x00\xef\x00\xd7\x03\x45\x00\x8c\x00\x46\x00\x40\x04\xad\x02\xd0\x00\x3e\x04\x39\x04\x33\x04\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xae\x02\x31\x03\x2d\x01\x31\x04\x30\x04\x2d\x04\x22\x01\x2f\x04\x71\x00\x23\x01\x2a\x04\x13\xfd\x42\x00\x43\x00\x12\xfd\x44\x00\x45\x00\x14\xfd\x46\x00\x47\x00\x48\x00\x20\x04\x1a\x04\x65\x03\x17\x04\x14\x04\x15\x04\x49\x00\x4a\x00\x4b\x00\x12\x04\x24\x01\x42\x00\x43\x00\x25\x01\x0e\x04\x45\x00\x68\x05\x46\x00\x4c\x00\x11\x00\x9c\x00\x9d\x00\x26\x01\x0a\x04\xc8\x02\x08\x04\x49\x00\x68\x00\x4b\x00\xff\x03\x9e\x00\x70\x00\xa9\x03\xce\x00\x71\x00\x72\x00\x8c\x00\xf2\x03\x4c\x00\xcf\x00\xd0\x00\xfa\x03\xef\x03\xeb\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\xec\x03\x3c\x02\xe3\x03\xe2\x03\xd7\x03\x08\x01\x4c\x01\xd1\x00\x9f\x00\x0f\x00\xd2\x00\xe1\x03\xa3\x04\x9b\x04\x95\x04\x08\x01\x11\x00\x07\x01\x7a\x00\x7b\x00\x92\x04\x6c\x02\xa0\x00\x90\x04\x88\x04\x36\x00\x37\x00\x38\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x02\x49\x04\x3d\x01\x89\x03\x3d\x00\x3e\x00\x3f\x00\x81\x04\x9c\x00\x9d\x00\x80\x04\xd0\x02\x7f\x04\x14\x04\x12\x04\x07\x01\x12\x04\x5f\x04\x9e\x00\x70\x00\x5b\x04\x56\x04\x71\x00\x72\x00\x36\x00\x37\x00\x38\x00\x52\x04\x50\x04\x4d\x01\x51\x04\x4e\x01\x49\x04\x3c\x00\xeb\x04\x3d\x00\x3e\x00\x3f\x00\x4f\x04\x6f\x03\x4d\x04\x4c\x04\x4b\x04\x4a\x04\x40\x00\xd1\x00\x9f\x00\x0f\x00\xd2\x00\xe8\x04\x58\x01\xda\x04\xe4\x04\xc7\x04\x11\x00\x12\x04\x7a\x00\x7b\x00\x65\x03\xbe\x01\xa0\x00\x36\x00\x37\x00\x38\x00\xbd\x04\xbe\x04\x4d\x01\xb3\x04\x4e\x01\x2f\x05\x3c\x00\x21\x05\x3d\x00\x3e\x00\x3f\x00\x40\x00\x79\x03\x70\x01\x71\x01\x72\x01\x23\x05\x73\x01\x1c\x05\x1b\x05\x15\x05\x22\x01\x08\x01\x71\x00\x23\x01\x36\x00\x37\x00\x38\x00\x0d\x05\x0e\x05\x4d\x01\x0c\x05\x4e\x01\x0b\x05\x3c\x00\x65\x05\x3d\x00\x3e\x00\x3f\x00\x64\x05\x5c\x05\x5a\x03\x62\x05\x4e\x05\x08\x01\x4d\x05\x24\x01\x4b\x05\x40\x00\x25\x01\x4a\x05\x08\x01\x45\x05\x42\x00\x43\x00\x11\x00\x44\x00\x45\x00\x26\x01\x46\x00\x47\x00\x48\x00\x7a\x05\x3c\x05\x3b\x05\x3a\x05\x39\x05\x33\x05\x49\x00\x4a\x00\x4b\x00\x73\x05\x7e\x05\x7d\x05\xd7\x03\x07\x01\x40\x00\x6d\x05\x14\x04\x68\xfe\x4c\x00\x36\x00\x37\x00\x38\x00\x42\x00\x43\x00\x12\x04\x44\x00\x45\x00\x68\x05\x46\x00\x47\x00\x48\x00\x8e\x05\x5b\x02\x12\x04\xd0\x03\x8a\x05\x89\x05\x49\x00\x4a\x00\x4b\x00\x93\x05\x36\x00\x37\x00\x38\x00\x40\x02\x92\x05\x3a\x00\x95\x05\x3b\x00\x4c\x00\x3c\x00\x08\x01\x3d\x00\x3e\x00\x3f\x00\x0b\x01\x00\x05\x01\x02\x8e\x01\x42\x00\x43\x00\xbf\x01\x44\x00\x45\x00\xd0\x01\x46\x00\x47\x00\x48\x00\xb7\x01\x82\x01\x40\x00\x55\x01\xb3\x01\x41\x01\x49\x00\x4a\x00\x4b\x00\x39\x01\x46\x01\x19\x01\x19\x03\x15\x03\x18\x03\x17\x03\xf4\x02\x0b\x03\x4c\x00\x42\x00\x43\x00\x08\x03\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x02\x03\xee\x02\xde\x02\xcf\x02\xc2\x02\x8c\x02\x49\x00\x4a\x00\x4b\x00\xe5\x01\x36\x00\x37\x00\x38\x00\x6a\x02\x15\x02\x4d\x01\xd4\x03\x4e\x01\x4c\x00\x3c\x00\xd3\x03\x3d\x00\x3e\x00\x3f\x00\x1e\x03\xd2\x03\x76\x02\x10\x02\x36\x00\x37\x00\x38\x00\xe2\x01\x0d\x02\x3a\x00\xbd\x03\x3b\x00\x68\x02\x3c\x00\x5d\x03\x3d\x00\x3e\x00\x3f\x00\xb6\x03\x58\x03\xa7\x03\xe3\x01\xe4\x01\x42\x00\x43\x00\x93\x03\x41\x00\x45\x00\x67\x03\x46\x00\x8a\x03\x56\x03\x54\x03\x89\x03\x67\x03\x4c\x03\x38\x03\x40\x00\x49\x00\x35\x03\x4b\x00\x33\x03\x25\x03\x24\x03\x21\x03\x42\x00\x43\x00\x47\x04\x44\x00\x45\x00\x4c\x00\x46\x00\x47\x00\x48\x00\x45\x04\x40\x00\x46\x04\x55\x00\x43\x04\x41\x04\x49\x00\x4a\x00\x4b\x00\x44\x04\xeb\x01\x31\x04\x9b\x02\xed\x01\x28\x04\x57\x00\x41\x02\x78\x00\x4c\x00\x79\x00\x25\x04\x18\x04\xd2\x01\x7d\x00\x40\x03\x1a\x04\x22\x04\xd3\x01\x36\x00\x37\x00\x38\x00\xe7\x01\x9c\x02\x3a\x00\xf8\x03\x3b\x00\x12\x04\x3c\x00\x6b\x01\x3d\x00\x3e\x00\x3f\x00\xef\x03\x63\x00\x64\x00\xed\x03\xd8\x03\x66\x00\x67\x00\xd7\x03\xd5\x03\x7d\x04\x90\x04\x78\x04\x77\x04\x41\x00\x42\x00\x43\x00\x68\x04\x44\x00\x45\x00\x5d\x04\x46\x00\x47\x00\x48\x00\x4d\x04\xee\x04\xeb\x04\xe9\x04\xe0\x04\xdf\x04\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\xde\x04\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x4c\x00\xda\x04\xd8\x04\xc5\x04\xbf\x04\x68\x02\x49\x00\x4a\x00\x4b\x00\xbb\x04\x36\x00\x37\x00\x38\x00\xe7\x01\xb3\x04\x3a\x00\xa3\x04\x3b\x00\x4c\x00\x3c\x00\x2d\x05\x3d\x00\x3e\x00\x3f\x00\xd2\x02\xa2\x02\x21\x05\xe5\x01\x36\x00\x37\x00\x38\x00\x59\x02\xa3\x02\xd3\x02\x2c\x05\x3b\x00\xa5\x02\xd4\x02\x1e\x05\x3d\x00\x3e\x00\x3f\x00\x13\x05\x6e\x01\x6f\x01\x70\x01\x71\x01\x72\x01\x0e\x05\x73\x01\x41\x00\x06\x05\x1d\x05\x22\x01\xf8\x04\x71\x00\x23\x01\xf1\x04\x65\x05\x58\x05\x5f\x05\x40\x00\x5e\x05\x67\x03\x55\x05\x74\x05\x43\x05\x42\x05\x73\x05\x42\x00\x43\x00\x6a\x05\x44\x00\x45\x00\x8f\x05\x46\x00\xe8\x01\x48\x00\x24\x01\x40\x00\x84\x05\x25\x01\x82\x05\x90\x05\x49\x00\x4a\x00\x4b\x00\x11\x00\x8e\x05\x00\x00\x26\x01\x93\x05\x00\x00\xb5\x02\x00\x00\x00\x00\x4c\x00\x36\x00\x37\x00\x38\x00\x59\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\xe9\x01\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\xe7\x02\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x03\x72\x01\x00\x00\x73\x01\x00\x00\x00\x00\x00\x00\x22\x01\x00\x00\x71\x00\x23\x01\xd5\x02\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\xe8\x01\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x6b\x05\x4a\x00\x4b\x00\x42\x00\x43\x00\x24\x01\x44\x00\x45\x00\x25\x01\x46\x00\x47\x00\x48\x00\x4c\x00\x00\x00\x11\x00\x00\x00\x00\x00\x26\x01\x49\x00\x4a\x00\x4b\x00\xe9\x01\xb5\x02\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x59\x02\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\xb6\x02\x00\x00\x84\x01\x85\x01\x43\x00\x00\x00\x00\x00\x45\x00\x00\x00\x46\x00\xb5\x02\x00\x00\x00\x00\x41\x00\x36\x00\x37\x00\x38\x00\x59\x02\x86\x01\x3a\x00\x4b\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x21\x04\x00\x00\x4c\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x05\x04\x00\x00\x00\x00\x08\x04\x36\x00\x37\x00\x38\x00\x59\x02\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x40\x00\x3d\x00\x3e\x00\x3f\x00\x05\x04\x00\x00\x00\x00\x06\x04\x36\x00\x37\x00\x38\x00\x59\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x94\x01\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x95\x01\x0f\x00\x10\x00\x00\x00\x40\x00\x49\x00\x4a\x00\x4b\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x41\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x47\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x05\x04\x00\x00\x00\x00\xc3\x04\x36\x00\x37\x00\x38\x00\x59\x02\x4c\x00\x3a\x00\x40\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x58\x02\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x59\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x05\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x59\x02\x40\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x42\x00\x43\x00\x00\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x49\x00\x00\x00\x4b\x00\x42\x00\x43\x00\xd5\x01\x00\x00\x45\x00\x00\x00\x46\x00\x80\x00\x81\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x49\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x01\x00\x00\x41\x00\x4c\x00\x00\x00\x00\x00\x6b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x17\x02\xa2\x00\x13\x00\xa3\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x3f\x03\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa3\x02\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x02\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\xb0\x03\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x04\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa3\x02\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\xa7\x02\x59\x04\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa3\x02\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x7f\x00\x82\x01\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x40\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\xe4\x04\x4c\x00\x82\x00\x36\x00\x37\x00\x38\x00\x50\x01\xa3\x02\xa4\x02\x00\x00\x40\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xc8\x01\x55\x01\x52\x01\x00\x00\x00\x00\x88\x00\x89\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x75\x00\x00\x00\x76\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x02\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x49\x02\x40\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\xa7\x02\x42\x00\x43\x00\xcb\x03\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x40\x00\xa8\x01\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\xa7\x02\x57\x05\x4c\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa3\x02\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x41\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x13\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x14\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x02\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\xa2\x00\x13\x00\xa3\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xa4\x00\x4c\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\xfa\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\x15\x00\x00\x00\xfc\x00\x00\x00\x16\x00\xfd\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x1e\x02\x1f\x02\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\xff\x00\xab\x00\xdc\x00\xad\x00\x00\x01\x01\x01\x00\x00\x00\x00\x02\x01\x03\x01\x04\x01\x05\x01\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x6e\x04\x6f\x04\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x70\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x7f\x00\x54\x01\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x80\x00\x81\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x01\xae\x00\x00\x00\x00\x00\x88\x00\x89\x00\x00\x00\xaf\x00\x8b\x00\x8c\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x65\x04\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\x15\x00\x00\x00\x66\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x7f\x00\x04\x05\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x80\x00\x81\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x01\xae\x00\x00\x00\x00\x00\x88\x00\x89\x00\x00\x00\xaf\x00\x8b\x00\x8c\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x6e\x04\x6f\x04\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x70\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x7f\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x80\x00\x81\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x01\xae\x00\x00\x00\x00\x00\x88\x00\x89\x00\x00\x00\xaf\x00\x8b\x00\x8c\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x65\x04\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\x15\x00\x00\x00\x66\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x7f\x00\xca\x01\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\xcb\x01\xcc\x01\xcd\x01\xce\x01\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\xae\x00\x00\x00\x68\x01\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x55\x01\x69\x01\x81\x00\x00\x00\x88\x00\x89\x00\x00\x00\x82\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x6a\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x6b\x01\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x7f\x00\x00\x00\x53\x04\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\xab\x00\xac\x00\xad\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x55\x01\xae\x00\x00\x00\x68\x01\x88\x00\x89\x00\x00\x00\xaf\x00\x8b\x00\x8c\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x9f\x01\xb6\x00\x00\x00\x00\x00\x6b\x01\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x50\x01\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x51\x01\x00\x00\x52\x01\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x76\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7f\x00\x00\x00\x00\x00\xae\x00\x00\x00\x68\x01\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x69\x01\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x6a\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x6b\x01\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x50\x01\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\xcc\x02\x00\x00\x52\x01\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x76\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7f\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x4f\x02\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x34\x02\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x50\x01\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\xc8\x01\x00\x00\x52\x01\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x76\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7f\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x52\x02\xb6\x00\x00\x00\x00\x00\x34\x02\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xd8\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xa7\x01\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\xc8\x02\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x34\x02\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x6c\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x03\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\xb0\x03\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\xa9\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\xbe\x01\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x01\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\xa9\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\xa2\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x05\x10\x05\x00\x00\x3d\x00\x3e\x00\x3f\x00\xae\x00\x11\x05\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xe8\xfd\xe8\xfd\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\xe8\xfd\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xfd\x00\x00\x00\x00\x00\x00\xe8\xfd\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\x00\x00\x00\x00\xe8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\x4c\x00\x00\x00\xe8\xfd\x00\x00\x00\x00\x00\x00\xe8\xfd\x00\x00\x00\x00\xe8\xfd\xe8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\x00\x00\x00\x00\x00\x00\xe8\xfd\x00\x00\xe8\xfd\x00\x00\xe8\xfd\x00\x00\xe8\xfd\x00\x00\xe8\xfd\x00\x00\x00\x00\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\x00\x00\xe8\xfd\x00\x00\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xe8\xfd\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\xb0\x03\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\xa9\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\xa2\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\xf5\x03\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x01\xab\x00\xd7\x01\xad\x00\x00\x00\xd8\x01\x00\x00\x00\x00\xd9\x01\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x05\x10\x05\xda\x01\x3d\x00\x3e\x00\x3f\x00\xae\x00\x6d\x05\x00\x00\x00\x00\xdb\x01\x00\x00\xaf\x00\x25\x01\x00\x00\xb0\x00\x00\x00\xdc\x01\x78\x00\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\xad\x01\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\xae\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x01\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x02\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\xae\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x02\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x98\x03\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\xaf\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2b\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xbd\x02\x70\x01\x71\x01\x72\x01\x00\x00\x73\x01\x00\x00\x00\x00\x00\x00\x22\x01\x00\x00\x71\x00\x23\x01\x00\x00\x36\x00\x37\x00\x38\x00\x49\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xe1\x02\x4b\x02\x00\x00\x00\x00\x24\x01\x00\x00\x00\x00\x25\x01\x00\x00\x00\x00\x00\x00\x41\x02\x78\x00\x11\x00\x79\x00\x00\x00\x26\x01\x00\x00\xbe\x02\xb2\x00\x00\x00\xb3\x00\xd3\x01\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x4e\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x41\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\xeb\x01\x00\x00\xec\x01\xed\x01\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\xee\x01\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x53\x00\x54\x00\x00\x00\x23\x02\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\xe7\x01\x40\x00\x00\x00\x00\x00\x6b\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x02\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x44\x02\x45\x02\x00\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x6a\x01\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x47\x02\x48\x02\x00\x00\x65\x00\x66\x00\x49\x02\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\x5f\x03\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\xf2\x01\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\xf0\x01\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x01\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x40\x01\x41\x01\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\x15\x04\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xd7\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\xfd\x03\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xa9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\x04\x05\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xa9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\x02\x05\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xd7\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xa9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xa9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xd7\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xa9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x04\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\xd7\x04\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xa9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x54\x05\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x13\x05\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x04\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x9c\xfe\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x02\x04\x02\x61\x00\x62\x00\x00\x00\x89\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x49\x02\x56\x00\x3a\x00\x00\x00\x3b\x00\x58\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x5a\x00\x4a\x02\x4b\x02\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x02\x04\x02\x61\x00\x62\x00\x00\x00\x89\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x56\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x4c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x02\x61\x00\x62\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x36\x00\x37\x00\x38\x00\x22\x02\xfc\x03\xd3\x02\x00\x00\x3b\x00\xa5\x02\xd4\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x21\x02\xfb\x03\xd3\x02\x00\x00\x3b\x00\xa5\x02\xd4\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xce\x03\x72\x04\xd3\x02\x00\x00\x3b\x00\xa5\x02\xd4\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xc9\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x02\x00\x00\x40\x00\x00\x00\xca\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\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\xd5\x02\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\xd5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\x49\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xc8\x03\x36\x00\x37\x00\x38\x00\xc6\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x49\x02\x40\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xc5\x03\x36\x00\x37\x00\x38\x00\xc9\x03\x40\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x41\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\xc9\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\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\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xc9\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x0c\x04\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x49\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xe3\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xc9\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x40\x00\x00\x00\xdc\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\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\xc9\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x05\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x2a\x04\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x05\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xf0\x01\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x05\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\xee\x01\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x91\x01\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x22\x02\x40\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x21\x02\x40\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x41\x00\x4a\x03\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x41\x00\x40\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x41\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\xa7\x02\x36\x00\x37\x00\x38\x00\xce\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x95\x03\x97\x00\x00\x00\x96\x03\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\x2a\x04\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xfc\x03\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x36\x00\x37\x00\x38\x00\x40\x00\xfb\x03\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x40\x00\x98\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x02\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x00\x00\xa7\x02\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\xdd\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x72\x04\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x40\x00\x73\x04\xa4\x02\x00\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xf6\x04\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x02\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x4c\x00\x00\x00\xa7\x02\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x42\x00\x43\x00\x13\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x4c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x46\x03\x47\x03\x48\x03\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x2a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x49\x03\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x2a\x02\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x2b\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x03\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x03\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x1e\x02\x1f\x02\x88\x05\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\xb9\x04\x29\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x1e\x02\x1f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x02\x1f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x20\x02\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x02\x1f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x13\x00\x00\x00\x84\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x86\x00\x00\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x01\xd2\x02\x13\x00\x00\x00\xdf\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\xe0\x01\x00\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x00\x00\x8a\x00\x00\x00\x8c\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x13\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x04\x00\x00\x00\x00\x15\x00\x00\x00\xaf\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\xb0\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\xb1\x04\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\xb2\x04\x00\x00\x00\x00\x2b\x00\x62\x00\x00\x00\xae\x04\x2c\x00\x65\x00\x15\x00\x00\x00\xaf\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\xb0\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x62\x00\x00\x00\x00\x00\x2c\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x13\x00\x00\x00\x00\x00\x97\x01\x00\x00\x85\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x15\x00\x00\x00\xaf\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x38\x05\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x62\x00\x00\x00\x00\x00\x2c\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\xde\x01\x00\x00\x00\x00\x00\x00\xdf\x01\x14\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x15\x00\x00\x00\x8a\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x88\x01\x00\x00\x89\x01\x00\x00\x8a\x01\x14\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x00\x00\x15\x00\x00\x00\x65\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x15\x00\x00\x00\x00\x00\x8a\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x13\x00\x00\x00\x20\x01\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x21\x01\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x00\x00\x00\x00\x16\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x61\x02\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x00\x00\x00\x00\x16\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x2b\x00\x00\x00\x00\x00\x16\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x13\x00\x00\x00\x00\x00\x75\x01\x6a\x01\x85\x00\x00\x00\x00\x00\x14\x00\x00\x00\x6b\x01\x00\x00\x00\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x28\x01\x00\x00\x00\x00\x15\x00\x00\x00\x29\x01\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x14\x00\x00\x00\x00\x00\x75\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x87\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x39\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x14\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x87\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x75\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x14\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x87\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\xff\x14\x00\x00\x00\x00\x00\x0e\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\xfb\x02\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xc5\x02\x00\x00\x24\x00\x2b\x00\x13\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x2b\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x13\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x04\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x2b\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x13\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x04\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x1f\x04\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x13\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\xfd\x01\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x61\x00\x00\x00\x5b\x01\x5c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x61\x01\x9f\x01\x63\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x64\x01\x7d\x00\xa0\x00\x00\x00\x00\x00\x65\x01\x00\x00\x66\x01\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x01\x5c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x61\x01\x62\x01\x63\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x64\x01\x7d\x00\xa0\x00\x00\x00\x00\x00\x65\x01\x00\x00\x66\x01\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x01\x9a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x00\x00\x00\x00\x9d\x01\x00\x00\x66\x01\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xab\x03\xac\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x01\x9f\x00\x0f\x00\x10\x00\xa4\x01\xa5\x01\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xae\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x01\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x02\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x02\x00\x00\x00\x00\x98\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\xa3\x03\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x9a\x03\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x59\x01\x5a\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5d\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\x5e\x01\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x60\x01\x9b\x01\x00\x00\x9c\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x03\x9d\x03\x9e\x03\x9f\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\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x9c\x03\x9d\x03\x9e\x03\x9f\x03\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x84\x04\x9e\x03\x9f\x03\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x9a\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x6f\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x6e\x02\x00\x00\x6f\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x65\x02\x66\x02\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xb0\x03\xab\x03\xac\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x60\x03\x66\x02\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xec\x03\xab\x03\xac\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xb9\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xba\x01\xbb\x01\xbc\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x82\x04\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x8a\x04\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\xad\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x3b\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x3a\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xe2\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xd5\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc7\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc6\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc0\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x93\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8c\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8b\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x61\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x57\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x56\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x55\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x54\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xb8\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xb7\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xb3\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xa5\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xa2\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x61\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x29\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x01\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xf3\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xe8\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xe6\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x89\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x88\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x81\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x71\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xe8\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc2\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc1\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc0\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xbe\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x1c\x05\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x45\x05\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x92\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\xc9\x02\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x37\x04\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\xd7\x04\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x8f\x00\x5a\x02\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x9e\x00\x70\x00\xd7\x02\x00\x00\x71\x00\x72\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x01\x95\x00\x96\x00\x97\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x79\x02\x7a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\xaa\x01\x95\x00\x96\x00\x97\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x79\x02\xa9\x03\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\xaa\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\x95\x00\x96\x00\x97\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\xab\x01\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x01\x95\x00\x96\x00\x97\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\xb2\x01\x95\x00\x96\x00\x97\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x9c\x00\x9d\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x01\x95\x00\x96\x00\x97\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\xa7\x01\x95\x00\x96\x00\x97\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x9c\x00\x9d\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x01\x95\x00\x96\x00\x97\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x1b\x01\x95\x00\x96\x00\x97\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x9c\x00\x9d\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x03\x95\x00\x96\x00\x97\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x0c\x03\x95\x00\x96\x00\x97\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x9c\x00\x9d\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\x95\x00\x96\x00\x97\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x75\x02\x95\x00\x96\x00\x97\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x9c\x00\x9d\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x02\x95\x00\x96\x00\x97\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x2f\x03\x95\x00\x96\x00\x97\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x9c\x00\x9d\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x97\x01\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 (13, 814) [- (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),- (630 , happyReduce_630),- (631 , happyReduce_631),- (632 , happyReduce_632),- (633 , happyReduce_633),- (634 , happyReduce_634),- (635 , happyReduce_635),- (636 , happyReduce_636),- (637 , happyReduce_637),- (638 , happyReduce_638),- (639 , happyReduce_639),- (640 , happyReduce_640),- (641 , happyReduce_641),- (642 , happyReduce_642),- (643 , happyReduce_643),- (644 , happyReduce_644),- (645 , happyReduce_645),- (646 , happyReduce_646),- (647 , happyReduce_647),- (648 , happyReduce_648),- (649 , happyReduce_649),- (650 , happyReduce_650),- (651 , happyReduce_651),- (652 , happyReduce_652),- (653 , happyReduce_653),- (654 , happyReduce_654),- (655 , happyReduce_655),- (656 , happyReduce_656),- (657 , happyReduce_657),- (658 , happyReduce_658),- (659 , happyReduce_659),- (660 , happyReduce_660),- (661 , happyReduce_661),- (662 , happyReduce_662),- (663 , happyReduce_663),- (664 , happyReduce_664),- (665 , happyReduce_665),- (666 , happyReduce_666),- (667 , happyReduce_667),- (668 , happyReduce_668),- (669 , happyReduce_669),- (670 , happyReduce_670),- (671 , happyReduce_671),- (672 , happyReduce_672),- (673 , happyReduce_673),- (674 , happyReduce_674),- (675 , happyReduce_675),- (676 , happyReduce_676),- (677 , happyReduce_677),- (678 , happyReduce_678),- (679 , happyReduce_679),- (680 , happyReduce_680),- (681 , happyReduce_681),- (682 , happyReduce_682),- (683 , happyReduce_683),- (684 , happyReduce_684),- (685 , happyReduce_685),- (686 , happyReduce_686),- (687 , happyReduce_687),- (688 , happyReduce_688),- (689 , happyReduce_689),- (690 , happyReduce_690),- (691 , happyReduce_691),- (692 , happyReduce_692),- (693 , happyReduce_693),- (694 , happyReduce_694),- (695 , happyReduce_695),- (696 , happyReduce_696),- (697 , happyReduce_697),- (698 , happyReduce_698),- (699 , happyReduce_699),- (700 , happyReduce_700),- (701 , happyReduce_701),- (702 , happyReduce_702),- (703 , happyReduce_703),- (704 , happyReduce_704),- (705 , happyReduce_705),- (706 , happyReduce_706),- (707 , happyReduce_707),- (708 , happyReduce_708),- (709 , happyReduce_709),- (710 , happyReduce_710),- (711 , happyReduce_711),- (712 , happyReduce_712),- (713 , happyReduce_713),- (714 , happyReduce_714),- (715 , happyReduce_715),- (716 , happyReduce_716),- (717 , happyReduce_717),- (718 , happyReduce_718),- (719 , happyReduce_719),- (720 , happyReduce_720),- (721 , happyReduce_721),- (722 , happyReduce_722),- (723 , happyReduce_723),- (724 , happyReduce_724),- (725 , happyReduce_725),- (726 , happyReduce_726),- (727 , happyReduce_727),- (728 , happyReduce_728),- (729 , happyReduce_729),- (730 , happyReduce_730),- (731 , happyReduce_731),- (732 , happyReduce_732),- (733 , happyReduce_733),- (734 , happyReduce_734),- (735 , happyReduce_735),- (736 , happyReduce_736),- (737 , happyReduce_737),- (738 , happyReduce_738),- (739 , happyReduce_739),- (740 , happyReduce_740),- (741 , happyReduce_741),- (742 , happyReduce_742),- (743 , happyReduce_743),- (744 , happyReduce_744),- (745 , happyReduce_745),- (746 , happyReduce_746),- (747 , happyReduce_747),- (748 , happyReduce_748),- (749 , happyReduce_749),- (750 , happyReduce_750),- (751 , happyReduce_751),- (752 , happyReduce_752),- (753 , happyReduce_753),- (754 , happyReduce_754),- (755 , happyReduce_755),- (756 , happyReduce_756),- (757 , happyReduce_757),- (758 , happyReduce_758),- (759 , happyReduce_759),- (760 , happyReduce_760),- (761 , happyReduce_761),- (762 , happyReduce_762),- (763 , happyReduce_763),- (764 , happyReduce_764),- (765 , happyReduce_765),- (766 , happyReduce_766),- (767 , happyReduce_767),- (768 , happyReduce_768),- (769 , happyReduce_769),- (770 , happyReduce_770),- (771 , happyReduce_771),- (772 , happyReduce_772),- (773 , happyReduce_773),- (774 , happyReduce_774),- (775 , happyReduce_775),- (776 , happyReduce_776),- (777 , happyReduce_777),- (778 , happyReduce_778),- (779 , happyReduce_779),- (780 , happyReduce_780),- (781 , happyReduce_781),- (782 , happyReduce_782),- (783 , happyReduce_783),- (784 , happyReduce_784),- (785 , happyReduce_785),- (786 , happyReduce_786),- (787 , happyReduce_787),- (788 , happyReduce_788),- (789 , happyReduce_789),- (790 , happyReduce_790),- (791 , happyReduce_791),- (792 , happyReduce_792),- (793 , happyReduce_793),- (794 , happyReduce_794),- (795 , happyReduce_795),- (796 , happyReduce_796),- (797 , happyReduce_797),- (798 , happyReduce_798),- (799 , happyReduce_799),- (800 , happyReduce_800),- (801 , happyReduce_801),- (802 , happyReduce_802),- (803 , happyReduce_803),- (804 , happyReduce_804),- (805 , happyReduce_805),- (806 , happyReduce_806),- (807 , happyReduce_807),- (808 , happyReduce_808),- (809 , happyReduce_809),- (810 , happyReduce_810),- (811 , happyReduce_811),- (812 , happyReduce_812),- (813 , happyReduce_813),- (814 , happyReduce_814)- ]--happy_n_terms = 156 :: Int-happy_n_nonterms = 302 :: Int--happyReduce_13 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_13 = happySpecReduce_1 0# happyReduction_13-happyReduction_13 happy_x_1- = case happyOut291 happy_x_1 of { happy_var_1 -> - happyIn16- (happy_var_1- )}--happyReduce_14 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_14 = happySpecReduce_1 0# happyReduction_14-happyReduction_14 happy_x_1- = case happyOut263 happy_x_1 of { happy_var_1 -> - happyIn16- (happy_var_1- )}--happyReduce_15 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_15 = happySpecReduce_1 0# happyReduction_15-happyReduction_15 happy_x_1- = case happyOut285 happy_x_1 of { happy_var_1 -> - happyIn16- (happy_var_1- )}--happyReduce_16 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_16 = happySpecReduce_1 0# happyReduction_16-happyReduction_16 happy_x_1- = case happyOut270 happy_x_1 of { happy_var_1 -> - happyIn16- (happy_var_1- )}--happyReduce_17 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_17 = happyMonadReduce 3# 0# happyReduction_17-happyReduction_17 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)- [mj AnnOpenP happy_var_1,mu AnnRarrow happy_var_2,mj AnnCloseP happy_var_3])}}})- ) (\r -> happyReturn (happyIn16 r))--happyReduce_18 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_18 = happySpecReduce_3 1# happyReduction_18-happyReduction_18 happy_x_3- happy_x_2- happy_x_1- = case happyOut18 happy_x_2 of { happy_var_2 -> - happyIn17- (fromOL happy_var_2- )}--happyReduce_19 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_19 = happySpecReduce_3 1# happyReduction_19-happyReduction_19 happy_x_3- happy_x_2- happy_x_1- = case happyOut18 happy_x_2 of { happy_var_2 -> - happyIn17- (fromOL happy_var_2- )}--happyReduce_20 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_20 = happySpecReduce_3 2# happyReduction_20-happyReduction_20 happy_x_3- happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn18- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_21 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_21 = happySpecReduce_2 2# happyReduction_21-happyReduction_21 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn18- (happy_var_1- )}--happyReduce_22 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_22 = happySpecReduce_1 2# happyReduction_22-happyReduction_22 happy_x_1- = case happyOut19 happy_x_1 of { happy_var_1 -> - happyIn18- (unitOL happy_var_1- )}--happyReduce_23 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_23 = happyReduce 4# 3# happyReduction_23-happyReduction_23 (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 happyOut24 happy_x_2 of { happy_var_2 -> - case happyOut30 happy_x_4 of { happy_var_4 -> - happyIn19- (sL1 happy_var_1 $ HsUnit { hsunitName = happy_var_2- , hsunitBody = fromOL happy_var_4 }- ) `HappyStk` happyRest}}}--happyReduce_24 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_24 = happySpecReduce_1 4# happyReduction_24-happyReduction_24 happy_x_1- = case happyOut24 happy_x_1 of { happy_var_1 -> - happyIn20- (sL1 happy_var_1 $ HsUnitId happy_var_1 []- )}--happyReduce_25 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_25 = happyReduce 4# 4# happyReduction_25-happyReduction_25 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut24 happy_x_1 of { happy_var_1 -> - case happyOut21 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn20- (sLL happy_var_1 happy_var_4 $ HsUnitId happy_var_1 (fromOL happy_var_3)- ) `HappyStk` happyRest}}}--happyReduce_26 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_26 = happySpecReduce_3 5# happyReduction_26-happyReduction_26 happy_x_3- happy_x_2- happy_x_1- = case happyOut21 happy_x_1 of { happy_var_1 -> - case happyOut22 happy_x_3 of { happy_var_3 -> - happyIn21- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_27 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_27 = happySpecReduce_2 5# happyReduction_27-happyReduction_27 happy_x_2- happy_x_1- = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn21- (happy_var_1- )}--happyReduce_28 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_28 = happySpecReduce_1 5# happyReduction_28-happyReduction_28 happy_x_1- = case happyOut22 happy_x_1 of { happy_var_1 -> - happyIn21- (unitOL happy_var_1- )}--happyReduce_29 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_29 = happySpecReduce_3 6# happyReduction_29-happyReduction_29 happy_x_3- happy_x_2- happy_x_1- = case happyOut307 happy_x_1 of { happy_var_1 -> - case happyOut23 happy_x_3 of { happy_var_3 -> - happyIn22- (sLL happy_var_1 happy_var_3 $ (happy_var_1, happy_var_3)- )}}--happyReduce_30 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_30 = happyReduce 4# 6# happyReduction_30-happyReduction_30 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut307 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn22- (sLL happy_var_1 happy_var_4 $ (happy_var_1, sLL happy_var_2 happy_var_4 $ HsModuleVar happy_var_3)- ) `HappyStk` happyRest}}}}--happyReduce_31 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_31 = happySpecReduce_3 7# happyReduction_31-happyReduction_31 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut307 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn23- (sLL happy_var_1 happy_var_3 $ HsModuleVar happy_var_2- )}}}--happyReduce_32 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_32 = happySpecReduce_3 7# happyReduction_32-happyReduction_32 happy_x_3- happy_x_2- happy_x_1- = case happyOut20 happy_x_1 of { happy_var_1 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - happyIn23- (sLL happy_var_1 happy_var_3 $ HsModuleId happy_var_1 happy_var_3- )}}--happyReduce_33 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_33 = happySpecReduce_1 8# happyReduction_33-happyReduction_33 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn24- (sL1 happy_var_1 $ PackageName (getSTRING happy_var_1)- )}--happyReduce_34 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_34 = happySpecReduce_1 8# happyReduction_34-happyReduction_34 happy_x_1- = case happyOut26 happy_x_1 of { happy_var_1 -> - happyIn24- (sL1 happy_var_1 $ PackageName (unLoc happy_var_1)- )}--happyReduce_35 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_35 = happySpecReduce_1 9# happyReduction_35-happyReduction_35 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn25- (sL1 happy_var_1 $ getVARID happy_var_1- )}--happyReduce_36 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_36 = happySpecReduce_1 9# happyReduction_36-happyReduction_36 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn25- (sL1 happy_var_1 $ getCONID happy_var_1- )}--happyReduce_37 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_37 = happySpecReduce_1 9# happyReduction_37-happyReduction_37 happy_x_1- = case happyOut299 happy_x_1 of { happy_var_1 -> - happyIn25- (happy_var_1- )}--happyReduce_38 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_38 = happySpecReduce_1 10# happyReduction_38-happyReduction_38 happy_x_1- = case happyOut25 happy_x_1 of { happy_var_1 -> - happyIn26- (happy_var_1- )}--happyReduce_39 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_39 = happySpecReduce_3 10# happyReduction_39-happyReduction_39 happy_x_3- happy_x_2- happy_x_1- = case happyOut25 happy_x_1 of { happy_var_1 -> - case happyOut26 happy_x_3 of { happy_var_3 -> - happyIn26- (sLL happy_var_1 happy_var_3 $ appendFS (unLoc happy_var_1) (consFS '-' (unLoc happy_var_3))- )}}--happyReduce_40 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_40 = happySpecReduce_0 11# happyReduction_40-happyReduction_40 = happyIn27- (Nothing- )--happyReduce_41 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_41 = happySpecReduce_3 11# happyReduction_41-happyReduction_41 happy_x_3- happy_x_2- happy_x_1- = case happyOut28 happy_x_2 of { happy_var_2 -> - happyIn27- (Just (fromOL happy_var_2)- )}--happyReduce_42 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_42 = happySpecReduce_3 12# happyReduction_42-happyReduction_42 happy_x_3- happy_x_2- happy_x_1- = case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn28- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_43 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_43 = happySpecReduce_2 12# happyReduction_43-happyReduction_43 happy_x_2- happy_x_1- = case happyOut28 happy_x_1 of { happy_var_1 -> - happyIn28- (happy_var_1- )}--happyReduce_44 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_44 = happySpecReduce_1 12# happyReduction_44-happyReduction_44 happy_x_1- = case happyOut29 happy_x_1 of { happy_var_1 -> - happyIn28- (unitOL happy_var_1- )}--happyReduce_45 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_45 = happySpecReduce_3 13# happyReduction_45-happyReduction_45 happy_x_3- happy_x_2- happy_x_1- = case happyOut307 happy_x_1 of { happy_var_1 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - happyIn29- (sLL happy_var_1 happy_var_3 $ Renaming happy_var_1 (Just happy_var_3)- )}}--happyReduce_46 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_46 = happySpecReduce_1 13# happyReduction_46-happyReduction_46 happy_x_1- = case happyOut307 happy_x_1 of { happy_var_1 -> - happyIn29- (sL1 happy_var_1 $ Renaming happy_var_1 Nothing- )}--happyReduce_47 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_47 = happySpecReduce_3 14# happyReduction_47-happyReduction_47 happy_x_3- happy_x_2- happy_x_1- = case happyOut31 happy_x_2 of { happy_var_2 -> - happyIn30- (happy_var_2- )}--happyReduce_48 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_48 = happySpecReduce_3 14# happyReduction_48-happyReduction_48 happy_x_3- happy_x_2- happy_x_1- = case happyOut31 happy_x_2 of { happy_var_2 -> - happyIn30- (happy_var_2- )}--happyReduce_49 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_49 = happySpecReduce_3 15# happyReduction_49-happyReduction_49 happy_x_3- happy_x_2- happy_x_1- = case happyOut31 happy_x_1 of { happy_var_1 -> - case happyOut32 happy_x_3 of { happy_var_3 -> - happyIn31- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_50 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_50 = happySpecReduce_2 15# happyReduction_50-happyReduction_50 happy_x_2- happy_x_1- = case happyOut31 happy_x_1 of { happy_var_1 -> - happyIn31- (happy_var_1- )}--happyReduce_51 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_51 = happySpecReduce_1 15# happyReduction_51-happyReduction_51 happy_x_1- = case happyOut32 happy_x_1 of { happy_var_1 -> - happyIn31- (unitOL happy_var_1- )}--happyReduce_52 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_52 = happyReduce 7# 16# happyReduction_52-happyReduction_52 (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 happyOut35 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - case happyOut38 happy_x_4 of { happy_var_4 -> - case happyOut48 happy_x_5 of { happy_var_5 -> - case happyOut39 happy_x_7 of { happy_var_7 -> - happyIn32- (sL1 happy_var_2 $ DeclD ModuleD happy_var_3 (Just (sL1 happy_var_2 (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7) (snd $ snd happy_var_7) happy_var_4 happy_var_1)))- ) `HappyStk` happyRest}}}}}}--happyReduce_53 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_53 = happyReduce 7# 16# happyReduction_53-happyReduction_53 (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 happyOut35 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - case happyOut38 happy_x_4 of { happy_var_4 -> - case happyOut48 happy_x_5 of { happy_var_5 -> - case happyOut39 happy_x_7 of { happy_var_7 -> - happyIn32- (sL1 happy_var_2 $ DeclD SignatureD happy_var_3 (Just (sL1 happy_var_2 (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7) (snd $ snd happy_var_7) happy_var_4 happy_var_1)))- ) `HappyStk` happyRest}}}}}}--happyReduce_54 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_54 = happySpecReduce_3 16# happyReduction_54-happyReduction_54 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - happyIn32- (sL1 happy_var_2 $ DeclD ModuleD happy_var_3 Nothing- )}}--happyReduce_55 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_55 = happySpecReduce_3 16# happyReduction_55-happyReduction_55 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - happyIn32- (sL1 happy_var_2 $ DeclD SignatureD happy_var_3 Nothing- )}}--happyReduce_56 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_56 = happySpecReduce_3 16# happyReduction_56-happyReduction_56 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_2 of { happy_var_2 -> - case happyOut27 happy_x_3 of { happy_var_3 -> - happyIn32- (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_2- , idModRenaming = happy_var_3- , idSignatureInclude = False })- )}}}--happyReduce_57 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_57 = happySpecReduce_3 16# happyReduction_57-happyReduction_57 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_3 of { happy_var_3 -> - happyIn32- (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_3- , idModRenaming = Nothing- , idSignatureInclude = True })- )}}--happyReduce_58 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_58 = happyMonadReduce 7# 17# happyReduction_58-happyReduction_58 (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 happyOut35 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - case happyOut38 happy_x_4 of { happy_var_4 -> - case happyOut48 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - case happyOut39 happy_x_7 of { happy_var_7 -> - ( fileSrcSpan >>= \ loc ->- ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)- (snd $ snd happy_var_7) happy_var_4 happy_var_1)- )- ([mj AnnSignature happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})- ) (\r -> happyReturn (happyIn33 r))--happyReduce_59 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_59 = happyMonadReduce 7# 18# happyReduction_59-happyReduction_59 (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 happyOut35 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - case happyOut38 happy_x_4 of { happy_var_4 -> - case happyOut48 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - case happyOut39 happy_x_7 of { happy_var_7 -> - ( fileSrcSpan >>= \ loc ->- ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)- (snd $ snd happy_var_7) happy_var_4 happy_var_1)- )- ([mj AnnModule happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})- ) (\r -> happyReturn (happyIn34 r))--happyReduce_60 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_60 = happyMonadReduce 1# 18# happyReduction_60-happyReduction_60 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut40 happy_x_1 of { happy_var_1 -> - ( fileSrcSpan >>= \ loc ->- ams (L loc (HsModule Nothing Nothing- (fst $ snd happy_var_1) (snd $ snd happy_var_1) Nothing Nothing))- (fst happy_var_1))})- ) (\r -> happyReturn (happyIn34 r))--happyReduce_61 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_61 = happySpecReduce_1 19# happyReduction_61-happyReduction_61 happy_x_1- = case happyOut315 happy_x_1 of { happy_var_1 -> - happyIn35- (happy_var_1- )}--happyReduce_62 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_62 = happySpecReduce_0 19# happyReduction_62-happyReduction_62 = happyIn35- (Nothing- )--happyReduce_63 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_63 = happyMonadReduce 0# 20# happyReduction_63-happyReduction_63 (happyRest) tk- = happyThen ((( pushModuleContext))- ) (\r -> happyReturn (happyIn36 r))--happyReduce_64 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_64 = happyMonadReduce 0# 21# happyReduction_64-happyReduction_64 (happyRest) tk- = happyThen ((( pushModuleContext))- ) (\r -> happyReturn (happyIn37 r))--happyReduce_65 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_65 = happyMonadReduce 3# 22# happyReduction_65-happyReduction_65 (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 happyOut134 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ajs (Just (sLL happy_var_1 happy_var_3 $ DeprecatedTxt (sL1 happy_var_1 (getDEPRECATED_PRAGs happy_var_1)) (snd $ unLoc happy_var_2)))- (mo happy_var_1:mc happy_var_3: (fst $ unLoc happy_var_2)))}}})- ) (\r -> happyReturn (happyIn38 r))--happyReduce_66 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_66 = happyMonadReduce 3# 22# happyReduction_66-happyReduction_66 (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 happyOut134 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ajs (Just (sLL happy_var_1 happy_var_3 $ WarningTxt (sL1 happy_var_1 (getWARNING_PRAGs happy_var_1)) (snd $ unLoc happy_var_2)))- (mo happy_var_1:mc happy_var_3 : (fst $ unLoc happy_var_2)))}}})- ) (\r -> happyReturn (happyIn38 r))--happyReduce_67 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_67 = happySpecReduce_0 22# happyReduction_67-happyReduction_67 = happyIn38- (Nothing- )--happyReduce_68 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_68 = happySpecReduce_3 23# happyReduction_68-happyReduction_68 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut41 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn39- ((moc happy_var_1:mcc happy_var_3:(fst happy_var_2)- , snd happy_var_2)- )}}}--happyReduce_69 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_69 = happySpecReduce_3 23# happyReduction_69-happyReduction_69 happy_x_3- happy_x_2- happy_x_1- = case happyOut41 happy_x_2 of { happy_var_2 -> - happyIn39- ((fst happy_var_2, snd happy_var_2)- )}--happyReduce_70 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_70 = happySpecReduce_3 24# happyReduction_70-happyReduction_70 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut41 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn40- ((moc happy_var_1:mcc happy_var_3- :(fst happy_var_2), snd happy_var_2)- )}}}--happyReduce_71 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_71 = happySpecReduce_3 24# happyReduction_71-happyReduction_71 happy_x_3- happy_x_2- happy_x_1- = case happyOut41 happy_x_2 of { happy_var_2 -> - happyIn40- (([],snd happy_var_2)- )}--happyReduce_72 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_72 = happySpecReduce_2 25# happyReduction_72-happyReduction_72 happy_x_2- happy_x_1- = case happyOut61 happy_x_1 of { happy_var_1 -> - case happyOut42 happy_x_2 of { happy_var_2 -> - happyIn41- ((happy_var_1, happy_var_2)- )}}--happyReduce_73 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_73 = happySpecReduce_2 26# happyReduction_73-happyReduction_73 happy_x_2- happy_x_1- = case happyOut63 happy_x_1 of { happy_var_1 -> - case happyOut76 happy_x_2 of { happy_var_2 -> - happyIn42- ((reverse happy_var_1, cvTopDecls happy_var_2)- )}}--happyReduce_74 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_74 = happySpecReduce_2 26# happyReduction_74-happyReduction_74 happy_x_2- happy_x_1- = case happyOut63 happy_x_1 of { happy_var_1 -> - case happyOut75 happy_x_2 of { happy_var_2 -> - happyIn42- ((reverse happy_var_1, cvTopDecls happy_var_2)- )}}--happyReduce_75 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_75 = happySpecReduce_1 26# happyReduction_75-happyReduction_75 happy_x_1- = case happyOut62 happy_x_1 of { happy_var_1 -> - happyIn42- ((reverse happy_var_1, [])- )}--happyReduce_76 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_76 = happyMonadReduce 7# 27# happyReduction_76-happyReduction_76 (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 happyOut35 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - case happyOut38 happy_x_4 of { happy_var_4 -> - case happyOut48 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - case happyOut44 happy_x_7 of { happy_var_7 -> - ( fileSrcSpan >>= \ loc ->- ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1- )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})- ) (\r -> happyReturn (happyIn43 r))--happyReduce_77 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_77 = happyMonadReduce 7# 27# happyReduction_77-happyReduction_77 (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 happyOut35 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut307 happy_x_3 of { happy_var_3 -> - case happyOut38 happy_x_4 of { happy_var_4 -> - case happyOut48 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - case happyOut44 happy_x_7 of { happy_var_7 -> - ( fileSrcSpan >>= \ loc ->- ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1- )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})- ) (\r -> happyReturn (happyIn43 r))--happyReduce_78 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_78 = happyMonadReduce 1# 27# happyReduction_78-happyReduction_78 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut45 happy_x_1 of { happy_var_1 -> - ( fileSrcSpan >>= \ loc ->- return (L loc (HsModule Nothing Nothing happy_var_1 [] Nothing- Nothing)))})- ) (\r -> happyReturn (happyIn43 r))--happyReduce_79 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_79 = happySpecReduce_2 28# happyReduction_79-happyReduction_79 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { happy_var_2 -> - happyIn44- (happy_var_2- )}--happyReduce_80 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_80 = happySpecReduce_2 28# happyReduction_80-happyReduction_80 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { happy_var_2 -> - happyIn44- (happy_var_2- )}--happyReduce_81 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_81 = happySpecReduce_2 29# happyReduction_81-happyReduction_81 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { happy_var_2 -> - happyIn45- (happy_var_2- )}--happyReduce_82 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_82 = happySpecReduce_2 29# happyReduction_82-happyReduction_82 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { happy_var_2 -> - happyIn45- (happy_var_2- )}--happyReduce_83 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_83 = happySpecReduce_2 30# happyReduction_83-happyReduction_83 happy_x_2- happy_x_1- = case happyOut47 happy_x_2 of { happy_var_2 -> - happyIn46- (happy_var_2- )}--happyReduce_84 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_84 = happySpecReduce_1 31# happyReduction_84-happyReduction_84 happy_x_1- = case happyOut63 happy_x_1 of { happy_var_1 -> - happyIn47- (happy_var_1- )}--happyReduce_85 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_85 = happySpecReduce_1 31# happyReduction_85-happyReduction_85 happy_x_1- = case happyOut62 happy_x_1 of { happy_var_1 -> - happyIn47- (happy_var_1- )}--happyReduce_86 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_86 = happyMonadReduce 3# 32# happyReduction_86-happyReduction_86 (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 happyOut49 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 ()) [mop happy_var_1,mcp happy_var_3] >>- return (Just (sLL happy_var_1 happy_var_3 (fromOL happy_var_2))))}}})- ) (\r -> happyReturn (happyIn48 r))--happyReduce_87 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_87 = happySpecReduce_0 32# happyReduction_87-happyReduction_87 = happyIn48- (Nothing- )--happyReduce_88 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_88 = happyMonadReduce 3# 33# happyReduction_88-happyReduction_88 (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 { happy_var_2 -> - case happyOut51 happy_x_3 of { happy_var_3 -> - ( addAnnotation (oll happy_var_1) AnnComma (gl happy_var_2)- >> return (happy_var_1 `appOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn49 r))--happyReduce_89 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_89 = happySpecReduce_1 33# happyReduction_89-happyReduction_89 happy_x_1- = case happyOut50 happy_x_1 of { happy_var_1 -> - happyIn49- (happy_var_1- )}--happyReduce_90 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_90 = happyMonadReduce 5# 34# happyReduction_90-happyReduction_90 (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 happyOut53 happy_x_2 of { happy_var_2 -> - case happyOut51 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut50 happy_x_5 of { happy_var_5 -> - ( (addAnnotation (oll (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3))- AnnComma (gl happy_var_4) ) >>- return (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3 `appOL` happy_var_5))}}}}})- ) (\r -> happyReturn (happyIn50 r))--happyReduce_91 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_91 = happySpecReduce_3 34# happyReduction_91-happyReduction_91 happy_x_3- happy_x_2- happy_x_1- = case happyOut51 happy_x_1 of { happy_var_1 -> - case happyOut53 happy_x_2 of { happy_var_2 -> - case happyOut51 happy_x_3 of { happy_var_3 -> - happyIn50- (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3- )}}}--happyReduce_92 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_92 = happySpecReduce_1 34# happyReduction_92-happyReduction_92 happy_x_1- = case happyOut51 happy_x_1 of { happy_var_1 -> - happyIn50- (happy_var_1- )}--happyReduce_93 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_93 = happySpecReduce_2 35# happyReduction_93-happyReduction_93 happy_x_2- happy_x_1- = case happyOut52 happy_x_1 of { happy_var_1 -> - case happyOut51 happy_x_2 of { happy_var_2 -> - happyIn51- (happy_var_1 `appOL` happy_var_2- )}}--happyReduce_94 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_94 = happySpecReduce_0 35# happyReduction_94-happyReduction_94 = happyIn51- (nilOL- )--happyReduce_95 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_95 = happySpecReduce_1 36# happyReduction_95-happyReduction_95 happy_x_1- = case happyOut314 happy_x_1 of { happy_var_1 -> - happyIn52- (unitOL (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> IEGroup n doc))- )}--happyReduce_96 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_96 = happySpecReduce_1 36# happyReduction_96-happyReduction_96 happy_x_1- = case happyOut313 happy_x_1 of { happy_var_1 -> - happyIn52- (unitOL (sL1 happy_var_1 (IEDocNamed ((fst . unLoc) happy_var_1)))- )}--happyReduce_97 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_97 = happySpecReduce_1 36# happyReduction_97-happyReduction_97 happy_x_1- = case happyOut311 happy_x_1 of { happy_var_1 -> - happyIn52- (unitOL (sL1 happy_var_1 (IEDoc (unLoc happy_var_1)))- )}--happyReduce_98 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_98 = happyMonadReduce 2# 37# happyReduction_98-happyReduction_98 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut58 happy_x_1 of { happy_var_1 -> - case happyOut54 happy_x_2 of { happy_var_2 -> - ( mkModuleImpExp happy_var_1 (snd $ unLoc happy_var_2)- >>= \ie -> amsu (sLL happy_var_1 happy_var_2 ie) (fst $ unLoc happy_var_2))}})- ) (\r -> happyReturn (happyIn53 r))--happyReduce_99 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_99 = happyMonadReduce 2# 37# happyReduction_99-happyReduction_99 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut307 happy_x_2 of { happy_var_2 -> - ( amsu (sLL happy_var_1 happy_var_2 (IEModuleContents happy_var_2))- [mj AnnModule happy_var_1])}})- ) (\r -> happyReturn (happyIn53 r))--happyReduce_100 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_100 = happyMonadReduce 2# 37# happyReduction_100-happyReduction_100 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut263 happy_x_2 of { happy_var_2 -> - ( amsu (sLL happy_var_1 happy_var_2 (IEVar (sLL happy_var_1 happy_var_2 (IEPattern happy_var_2))))- [mj AnnPattern happy_var_1])}})- ) (\r -> happyReturn (happyIn53 r))--happyReduce_101 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_101 = happySpecReduce_0 38# happyReduction_101-happyReduction_101 = happyIn54- (sL0 ([],ImpExpAbs)- )--happyReduce_102 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_102 = happyMonadReduce 3# 38# 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 { happy_var_1 -> - case happyOut55 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( mkImpExpSubSpec (reverse (snd happy_var_2))- >>= \(as,ie) -> return $ sLL happy_var_1 happy_var_3- (as ++ [mop happy_var_1,mcp happy_var_3] ++ fst happy_var_2, ie))}}})- ) (\r -> happyReturn (happyIn54 r))--happyReduce_103 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_103 = happySpecReduce_0 39# happyReduction_103-happyReduction_103 = happyIn55- (([],[])- )--happyReduce_104 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_104 = happySpecReduce_1 39# happyReduction_104-happyReduction_104 happy_x_1- = case happyOut56 happy_x_1 of { happy_var_1 -> - happyIn55- (happy_var_1- )}--happyReduce_105 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_105 = happyMonadReduce 3# 40# happyReduction_105-happyReduction_105 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut56 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut57 happy_x_3 of { happy_var_3 -> - ( case (head (snd happy_var_1)) of- l@(L _ ImpExpQcWildcard) ->- return ([mj AnnComma happy_var_2, mj AnnDotdot l]- ,(snd (unLoc happy_var_3) : snd happy_var_1))- l -> (ams (head (snd happy_var_1)) [mj AnnComma happy_var_2] >>- return (fst happy_var_1 ++ fst (unLoc happy_var_3),- snd (unLoc happy_var_3) : snd happy_var_1)))}}})- ) (\r -> happyReturn (happyIn56 r))--happyReduce_106 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_106 = happySpecReduce_1 40# happyReduction_106-happyReduction_106 happy_x_1- = case happyOut57 happy_x_1 of { happy_var_1 -> - happyIn56- ((fst (unLoc happy_var_1),[snd (unLoc happy_var_1)])- )}--happyReduce_107 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_107 = happySpecReduce_1 41# happyReduction_107-happyReduction_107 happy_x_1- = case happyOut58 happy_x_1 of { happy_var_1 -> - happyIn57- (sL1 happy_var_1 ([],happy_var_1)- )}--happyReduce_108 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_108 = happySpecReduce_1 41# happyReduction_108-happyReduction_108 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn57- (sL1 happy_var_1 ([mj AnnDotdot happy_var_1], sL1 happy_var_1 ImpExpQcWildcard)- )}--happyReduce_109 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_109 = happySpecReduce_1 42# happyReduction_109-happyReduction_109 happy_x_1- = case happyOut59 happy_x_1 of { happy_var_1 -> - happyIn58- (sL1 happy_var_1 (ImpExpQcName happy_var_1)- )}--happyReduce_110 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_110 = happyMonadReduce 2# 42# happyReduction_110-happyReduction_110 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut273 happy_x_2 of { happy_var_2 -> - ( do { n <- mkTypeImpExp happy_var_2- ; ams (sLL happy_var_1 happy_var_2 (ImpExpQcType n))- [mj AnnType happy_var_1] })}})- ) (\r -> happyReturn (happyIn58 r))--happyReduce_111 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_111 = happySpecReduce_1 43# happyReduction_111-happyReduction_111 happy_x_1- = case happyOut291 happy_x_1 of { happy_var_1 -> - happyIn59- (happy_var_1- )}--happyReduce_112 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_112 = happySpecReduce_1 43# happyReduction_112-happyReduction_112 happy_x_1- = case happyOut274 happy_x_1 of { happy_var_1 -> - happyIn59- (happy_var_1- )}--happyReduce_113 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_113 = happySpecReduce_2 44# happyReduction_113-happyReduction_113 happy_x_2- happy_x_1- = case happyOut60 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn60- (mj AnnSemi happy_var_2 : happy_var_1- )}}--happyReduce_114 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_114 = happySpecReduce_1 44# happyReduction_114-happyReduction_114 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn60- ([mj AnnSemi happy_var_1]- )}--happyReduce_115 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_115 = happySpecReduce_2 45# happyReduction_115-happyReduction_115 happy_x_2- happy_x_1- = case happyOut61 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn61- (mj AnnSemi happy_var_2 : happy_var_1- )}}--happyReduce_116 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_116 = happySpecReduce_0 45# happyReduction_116-happyReduction_116 = happyIn61- ([]- )--happyReduce_117 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_117 = happySpecReduce_2 46# happyReduction_117-happyReduction_117 happy_x_2- happy_x_1- = case happyOut63 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_2 of { happy_var_2 -> - happyIn62- (happy_var_2 : happy_var_1- )}}--happyReduce_118 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_118 = happyMonadReduce 3# 47# happyReduction_118-happyReduction_118 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut63 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_2 of { happy_var_2 -> - case happyOut60 happy_x_3 of { happy_var_3 -> - ( ams happy_var_2 happy_var_3 >> return (happy_var_2 : happy_var_1))}}})- ) (\r -> happyReturn (happyIn63 r))--happyReduce_119 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_119 = happySpecReduce_0 47# happyReduction_119-happyReduction_119 = happyIn63- ([]- )--happyReduce_120 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_120 = happyMonadReduce 8# 48# happyReduction_120-happyReduction_120 (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 { happy_var_1 -> - case happyOut65 happy_x_2 of { happy_var_2 -> - case happyOut66 happy_x_3 of { happy_var_3 -> - case happyOut68 happy_x_4 of { happy_var_4 -> - case happyOut67 happy_x_5 of { happy_var_5 -> - case happyOut307 happy_x_6 of { happy_var_6 -> - case happyOut69 happy_x_7 of { happy_var_7 -> - case happyOut70 happy_x_8 of { happy_var_8 -> - ( ams (L (comb4 happy_var_1 happy_var_6 (snd happy_var_7) happy_var_8) $- ImportDecl { ideclSourceSrc = snd $ fst happy_var_2- , ideclName = happy_var_6, ideclPkgQual = snd happy_var_5- , ideclSource = snd happy_var_2, ideclSafe = snd happy_var_3- , ideclQualified = snd happy_var_4, ideclImplicit = False- , ideclAs = unLoc (snd happy_var_7)- , ideclHiding = unLoc happy_var_8 })- ((mj AnnImport happy_var_1 : (fst $ fst happy_var_2) ++ fst happy_var_3 ++ fst happy_var_4- ++ fst happy_var_5 ++ fst happy_var_7)))}}}}}}}})- ) (\r -> happyReturn (happyIn64 r))--happyReduce_121 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_121 = happySpecReduce_2 49# happyReduction_121-happyReduction_121 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn65- ((([mo happy_var_1,mc happy_var_2],getSOURCE_PRAGs happy_var_1)- ,True)- )}}--happyReduce_122 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_122 = happySpecReduce_0 49# happyReduction_122-happyReduction_122 = happyIn65- ((([],NoSourceText),False)- )--happyReduce_123 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_123 = happySpecReduce_1 50# happyReduction_123-happyReduction_123 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn66- (([mj AnnSafe happy_var_1],True)- )}--happyReduce_124 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_124 = happySpecReduce_0 50# happyReduction_124-happyReduction_124 = happyIn66- (([],False)- )--happyReduce_125 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_125 = happyMonadReduce 1# 51# happyReduction_125-happyReduction_125 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( let pkgFS = getSTRING happy_var_1 in- if looksLikePackageName (unpackFS pkgFS)- then return ([mj AnnPackageName happy_var_1], Just (StringLiteral (getSTRINGs happy_var_1) pkgFS))- else parseErrorSDoc (getLoc happy_var_1) $ vcat [- text "parse error" <> colon <+> quotes (ppr pkgFS),- text "Version number or non-alphanumeric" <+>- text "character in package name"])})- ) (\r -> happyReturn (happyIn67 r))--happyReduce_126 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_126 = happySpecReduce_0 51# happyReduction_126-happyReduction_126 = happyIn67- (([],Nothing)- )--happyReduce_127 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_127 = happySpecReduce_1 52# happyReduction_127-happyReduction_127 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn68- (([mj AnnQualified happy_var_1],True)- )}--happyReduce_128 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_128 = happySpecReduce_0 52# happyReduction_128-happyReduction_128 = happyIn68- (([],False)- )--happyReduce_129 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_129 = happySpecReduce_2 53# happyReduction_129-happyReduction_129 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut307 happy_x_2 of { happy_var_2 -> - happyIn69- (([mj AnnAs happy_var_1]- ,sLL happy_var_1 happy_var_2 (Just happy_var_2))- )}}--happyReduce_130 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_130 = happySpecReduce_0 53# happyReduction_130-happyReduction_130 = happyIn69- (([],noLoc Nothing)- )--happyReduce_131 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_131 = happyMonadReduce 1# 54# happyReduction_131-happyReduction_131 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut71 happy_x_1 of { happy_var_1 -> - ( let (b, ie) = unLoc happy_var_1 in- checkImportSpec ie- >>= \checkedIe ->- return (L (gl happy_var_1) (Just (b, checkedIe))))})- ) (\r -> happyReturn (happyIn70 r))--happyReduce_132 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_132 = happySpecReduce_0 54# happyReduction_132-happyReduction_132 = happyIn70- (noLoc Nothing- )--happyReduce_133 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_133 = happyMonadReduce 3# 55# happyReduction_133-happyReduction_133 (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 happyOut49 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (False,- sLL happy_var_1 happy_var_3 $ fromOL happy_var_2))- [mop happy_var_1,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn71 r))--happyReduce_134 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_134 = happyMonadReduce 4# 55# happyReduction_134-happyReduction_134 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut49 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 (True,- sLL happy_var_1 happy_var_4 $ fromOL happy_var_3))- [mj AnnHiding happy_var_1,mop happy_var_2,mcp happy_var_4])}}}})- ) (\r -> happyReturn (happyIn71 r))--happyReduce_135 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_135 = happySpecReduce_0 56# happyReduction_135-happyReduction_135 = happyIn72- (noLoc (NoSourceText,9)- )--happyReduce_136 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_136 = happyMonadReduce 1# 56# happyReduction_136-happyReduction_136 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( checkPrecP (sL1 happy_var_1 (getINTEGERs happy_var_1,fromInteger (getINTEGER happy_var_1))))})- ) (\r -> happyReturn (happyIn72 r))--happyReduce_137 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_137 = happySpecReduce_1 57# happyReduction_137-happyReduction_137 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn73- (sL1 happy_var_1 InfixN- )}--happyReduce_138 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_138 = happySpecReduce_1 57# happyReduction_138-happyReduction_138 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn73- (sL1 happy_var_1 InfixL- )}--happyReduce_139 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_139 = happySpecReduce_1 57# happyReduction_139-happyReduction_139 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn73- (sL1 happy_var_1 InfixR- )}--happyReduce_140 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_140 = happyMonadReduce 3# 58# happyReduction_140-happyReduction_140 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut74 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut281 happy_x_3 of { happy_var_3 -> - ( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 ((unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})- ) (\r -> happyReturn (happyIn74 r))--happyReduce_141 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_141 = happySpecReduce_1 58# happyReduction_141-happyReduction_141 happy_x_1- = case happyOut281 happy_x_1 of { happy_var_1 -> - happyIn74- (sL1 happy_var_1 (unitOL happy_var_1)- )}--happyReduce_142 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_142 = happySpecReduce_2 59# happyReduction_142-happyReduction_142 happy_x_2- happy_x_1- = case happyOut76 happy_x_1 of { happy_var_1 -> - case happyOut77 happy_x_2 of { happy_var_2 -> - happyIn75- (happy_var_1 `snocOL` happy_var_2- )}}--happyReduce_143 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_143 = happyMonadReduce 3# 60# happyReduction_143-happyReduction_143 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut76 happy_x_1 of { happy_var_1 -> - case happyOut77 happy_x_2 of { happy_var_2 -> - case happyOut60 happy_x_3 of { happy_var_3 -> - ( ams happy_var_2 happy_var_3 >> return (happy_var_1 `snocOL` happy_var_2))}}})- ) (\r -> happyReturn (happyIn76 r))--happyReduce_144 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_144 = happySpecReduce_0 60# happyReduction_144-happyReduction_144 = happyIn76- (nilOL- )--happyReduce_145 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_145 = happySpecReduce_1 61# happyReduction_145-happyReduction_145 happy_x_1- = case happyOut78 happy_x_1 of { happy_var_1 -> - happyIn77- (sL1 happy_var_1 (TyClD (unLoc happy_var_1))- )}--happyReduce_146 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_146 = happySpecReduce_1 61# happyReduction_146-happyReduction_146 happy_x_1- = case happyOut79 happy_x_1 of { happy_var_1 -> - happyIn77- (sL1 happy_var_1 (TyClD (unLoc happy_var_1))- )}--happyReduce_147 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_147 = happySpecReduce_1 61# happyReduction_147-happyReduction_147 happy_x_1- = case happyOut80 happy_x_1 of { happy_var_1 -> - happyIn77- (sL1 happy_var_1 (InstD (unLoc happy_var_1))- )}--happyReduce_148 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_148 = happySpecReduce_1 61# happyReduction_148-happyReduction_148 happy_x_1- = case happyOut100 happy_x_1 of { happy_var_1 -> - happyIn77- (sLL happy_var_1 happy_var_1 (DerivD (unLoc happy_var_1))- )}--happyReduce_149 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_149 = happySpecReduce_1 61# happyReduction_149-happyReduction_149 happy_x_1- = case happyOut101 happy_x_1 of { happy_var_1 -> - happyIn77- (sL1 happy_var_1 (RoleAnnotD (unLoc happy_var_1))- )}--happyReduce_150 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_150 = happyMonadReduce 4# 61# happyReduction_150-happyReduction_150 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut164 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 (DefD (DefaultDecl happy_var_3)))- [mj AnnDefault happy_var_1- ,mop happy_var_2,mcp happy_var_4])}}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_151 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_151 = happyMonadReduce 2# 61# happyReduction_151-happyReduction_151 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut137 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 (snd $ unLoc happy_var_2))- (mj AnnForeign happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_152 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_152 = happyMonadReduce 3# 61# happyReduction_152-happyReduction_152 (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 happyOut132 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ WarningD (Warnings (getDEPRECATED_PRAGs happy_var_1) (fromOL happy_var_2)))- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_153 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_153 = happyMonadReduce 3# 61# happyReduction_153-happyReduction_153 (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 happyOut130 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ WarningD (Warnings (getWARNING_PRAGs happy_var_1) (fromOL happy_var_2)))- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_154 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_154 = happyMonadReduce 3# 61# happyReduction_154-happyReduction_154 (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 happyOut123 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ RuleD (HsRules (getRULES_PRAGs happy_var_1) (fromOL happy_var_2)))- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_155 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_155 = happyMonadReduce 5# 61# happyReduction_155-happyReduction_155 (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 happyOut291 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( ams (sLL happy_var_1 happy_var_5 $ VectD (HsVect (getVECT_PRAGs happy_var_1) happy_var_2 happy_var_4))- [mo happy_var_1,mj AnnEqual happy_var_3- ,mc happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_156 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_156 = happyMonadReduce 3# 61# happyReduction_156-happyReduction_156 (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 happyOut291 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ VectD (HsNoVect (getNOVECT_PRAGs happy_var_1) happy_var_2))- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_157 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_157 = happyMonadReduce 4# 61# happyReduction_157-happyReduction_157 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut271 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $- VectD (HsVectTypeIn (getVECT_PRAGs happy_var_1) False happy_var_3 Nothing))- [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_4])}}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_158 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_158 = happyMonadReduce 4# 61# happyReduction_158-happyReduction_158 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut271 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $- VectD (HsVectTypeIn (getVECT_SCALAR_PRAGs happy_var_1) True happy_var_3 Nothing))- [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_4])}}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_159 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_159 = happyMonadReduce 6# 61# happyReduction_159-happyReduction_159 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut271 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut271 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( ams (sLL happy_var_1 happy_var_6 $- VectD (HsVectTypeIn (getVECT_PRAGs happy_var_1) False happy_var_3 (Just happy_var_5)))- [mo happy_var_1,mj AnnType happy_var_2,mj AnnEqual happy_var_4,mc happy_var_6])}}}}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_160 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_160 = happyMonadReduce 6# 61# 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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut271 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut271 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( ams (sLL happy_var_1 happy_var_6 $- VectD (HsVectTypeIn (getVECT_SCALAR_PRAGs happy_var_1) True happy_var_3 (Just happy_var_5)))- [mo happy_var_1,mj AnnType happy_var_2,mj AnnEqual happy_var_4,mc happy_var_6])}}}}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_161 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_161 = happyMonadReduce 4# 61# happyReduction_161-happyReduction_161 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut271 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $ VectD (HsVectClassIn (getVECT_PRAGs happy_var_1) happy_var_3))- [mo happy_var_1,mj AnnClass happy_var_2,mc happy_var_4])}}}})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_162 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_162 = happySpecReduce_1 61# happyReduction_162-happyReduction_162 happy_x_1- = case happyOut136 happy_x_1 of { happy_var_1 -> - happyIn77- (happy_var_1- )}--happyReduce_163 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_163 = happySpecReduce_1 61# happyReduction_163-happyReduction_163 happy_x_1- = case happyOut191 happy_x_1 of { happy_var_1 -> - happyIn77- (happy_var_1- )}--happyReduce_164 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_164 = happySpecReduce_1 61# happyReduction_164-happyReduction_164 happy_x_1- = case happyOut202 happy_x_1 of { happy_var_1 -> - happyIn77- (sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1- )}--happyReduce_165 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_165 = happyMonadReduce 4# 62# happyReduction_165-happyReduction_165 (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 happyOut98 happy_x_2 of { happy_var_2 -> - case happyOut169 happy_x_3 of { happy_var_3 -> - case happyOut114 happy_x_4 of { happy_var_4 -> - ( amms (mkClassDecl (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4) happy_var_2 happy_var_3 (snd $ unLoc happy_var_4))- (mj AnnClass happy_var_1:(fst $ unLoc happy_var_3)++(fst $ unLoc happy_var_4)))}}}})- ) (\r -> happyReturn (happyIn78 r))--happyReduce_166 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_166 = happyMonadReduce 4# 63# happyReduction_166-happyReduction_166 (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 happyOut155 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut152 happy_x_4 of { happy_var_4 -> - ( amms (mkTySynonym (comb2 happy_var_1 happy_var_4) happy_var_2 happy_var_4)- [mj AnnType happy_var_1,mj AnnEqual happy_var_3])}}}})- ) (\r -> happyReturn (happyIn79 r))--happyReduce_167 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_167 = happyMonadReduce 6# 63# happyReduction_167-happyReduction_167 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_3 of { happy_var_3 -> - case happyOut96 happy_x_4 of { happy_var_4 -> - case happyOut83 happy_x_5 of { happy_var_5 -> - case happyOut86 happy_x_6 of { happy_var_6 -> - ( amms (mkFamDecl (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_6) happy_var_3- (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5))- (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)- ++ (fst $ unLoc happy_var_5) ++ (fst $ unLoc happy_var_6)))}}}}}})- ) (\r -> happyReturn (happyIn79 r))--happyReduce_168 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_168 = happyMonadReduce 5# 63# happyReduction_168-happyReduction_168 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut93 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_2 of { happy_var_2 -> - case happyOut98 happy_x_3 of { happy_var_3 -> - case happyOut178 happy_x_4 of { happy_var_4 -> - case happyOut186 happy_x_5 of { happy_var_5 -> - ( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3- Nothing (reverse (snd $ unLoc happy_var_4))- (fmap reverse happy_var_5))- -- We need the location on tycl_hdr in case- -- constrs and deriving are both empty- ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)))}}}}})- ) (\r -> happyReturn (happyIn79 r))--happyReduce_169 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_169 = happyMonadReduce 6# 63# happyReduction_169-happyReduction_169 (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 happyOut93 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_2 of { happy_var_2 -> - case happyOut98 happy_x_3 of { happy_var_3 -> - case happyOut94 happy_x_4 of { happy_var_4 -> - case happyOut174 happy_x_5 of { happy_var_5 -> - case happyOut186 happy_x_6 of { happy_var_6 -> - ( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3- (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)- (fmap reverse happy_var_6) )- -- We need the location on tycl_hdr in case- -- constrs and deriving are both empty- ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})- ) (\r -> happyReturn (happyIn79 r))--happyReduce_170 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_170 = happyMonadReduce 4# 63# happyReduction_170-happyReduction_170 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_3 of { happy_var_3 -> - case happyOut95 happy_x_4 of { happy_var_4 -> - ( amms (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_4) DataFamily happy_var_3- (snd $ unLoc happy_var_4) Nothing)- (mj AnnData happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})- ) (\r -> happyReturn (happyIn79 r))--happyReduce_171 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_171 = happyMonadReduce 4# 64# happyReduction_171-happyReduction_171 (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 happyOut81 happy_x_2 of { happy_var_2 -> - case happyOut162 happy_x_3 of { happy_var_3 -> - case happyOut118 happy_x_4 of { happy_var_4 -> - ( do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc happy_var_4)- ; let cid = ClsInstDecl { cid_poly_ty = happy_var_3, cid_binds = binds- , cid_sigs = mkClassOpSigs sigs- , cid_tyfam_insts = ats- , cid_overlap_mode = happy_var_2- , cid_datafam_insts = adts }- ; ams (L (comb3 happy_var_1 (hsSigType happy_var_3) happy_var_4) (ClsInstD { cid_inst = cid }))- (mj AnnInstance happy_var_1 : (fst $ unLoc happy_var_4)) })}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_172 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_172 = happyMonadReduce 3# 64# happyReduction_172-happyReduction_172 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut89 happy_x_3 of { happy_var_3 -> - ( ams happy_var_3 (fst $ unLoc happy_var_3)- >> amms (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3))- (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_173 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_173 = happyMonadReduce 6# 64# happyReduction_173-happyReduction_173 (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 happyOut93 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - case happyOut98 happy_x_4 of { happy_var_4 -> - case happyOut178 happy_x_5 of { happy_var_5 -> - case happyOut186 happy_x_6 of { happy_var_6 -> - ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 happy_var_4- Nothing (reverse (snd $ unLoc happy_var_5))- (fmap reverse happy_var_6))- ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2:(fst $ unLoc happy_var_5)))}}}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_174 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_174 = happyMonadReduce 7# 64# happyReduction_174-happyReduction_174 (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 happyOut93 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - case happyOut98 happy_x_4 of { happy_var_4 -> - case happyOut94 happy_x_5 of { happy_var_5 -> - case happyOut174 happy_x_6 of { happy_var_6 -> - case happyOut186 happy_x_7 of { happy_var_7 -> - ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3 happy_var_4- (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)- (fmap reverse happy_var_7))- ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2- :(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_175 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_175 = happyMonadReduce 2# 65# happyReduction_175-happyReduction_175 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ajs (Just (sLL happy_var_1 happy_var_2 (Overlappable (getOVERLAPPABLE_PRAGs happy_var_1))))- [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn81 r))--happyReduce_176 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_176 = happyMonadReduce 2# 65# happyReduction_176-happyReduction_176 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ajs (Just (sLL happy_var_1 happy_var_2 (Overlapping (getOVERLAPPING_PRAGs happy_var_1))))- [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn81 r))--happyReduce_177 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_177 = happyMonadReduce 2# 65# happyReduction_177-happyReduction_177 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ajs (Just (sLL happy_var_1 happy_var_2 (Overlaps (getOVERLAPS_PRAGs happy_var_1))))- [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn81 r))--happyReduce_178 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-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 { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ajs (Just (sLL happy_var_1 happy_var_2 (Incoherent (getINCOHERENT_PRAGs happy_var_1))))- [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn81 r))--happyReduce_179 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_179 = happySpecReduce_0 65# happyReduction_179-happyReduction_179 = happyIn81- (Nothing- )--happyReduce_180 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_180 = happyMonadReduce 1# 66# happyReduction_180-happyReduction_180 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( ajs (Just (sL1 happy_var_1 StockStrategy))- [mj AnnStock happy_var_1])})- ) (\r -> happyReturn (happyIn82 r))--happyReduce_181 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_181 = happyMonadReduce 1# 66# happyReduction_181-happyReduction_181 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( ajs (Just (sL1 happy_var_1 AnyclassStrategy))- [mj AnnAnyclass happy_var_1])})- ) (\r -> happyReturn (happyIn82 r))--happyReduce_182 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_182 = happyMonadReduce 1# 66# happyReduction_182-happyReduction_182 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( ajs (Just (sL1 happy_var_1 NewtypeStrategy))- [mj AnnNewtype happy_var_1])})- ) (\r -> happyReturn (happyIn82 r))--happyReduce_183 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_183 = happySpecReduce_0 66# happyReduction_183-happyReduction_183 = happyIn82- (Nothing- )--happyReduce_184 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_184 = happySpecReduce_0 67# happyReduction_184-happyReduction_184 = happyIn83- (noLoc ([], Nothing)- )--happyReduce_185 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_185 = happySpecReduce_2 67# happyReduction_185-happyReduction_185 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut84 happy_x_2 of { happy_var_2 -> - happyIn83- (sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]- , Just (happy_var_2))- )}}--happyReduce_186 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_186 = happyMonadReduce 3# 68# happyReduction_186-happyReduction_186 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut289 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut85 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (InjectivityAnn happy_var_1 (reverse (unLoc happy_var_3))))- [mu AnnRarrow happy_var_2])}}})- ) (\r -> happyReturn (happyIn84 r))--happyReduce_187 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_187 = happySpecReduce_2 69# happyReduction_187-happyReduction_187 happy_x_2- happy_x_1- = case happyOut85 happy_x_1 of { happy_var_1 -> - case happyOut289 happy_x_2 of { happy_var_2 -> - happyIn85- (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)- )}}--happyReduce_188 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_188 = happySpecReduce_1 69# happyReduction_188-happyReduction_188 happy_x_1- = case happyOut289 happy_x_1 of { happy_var_1 -> - happyIn85- (sLL happy_var_1 happy_var_1 [happy_var_1]- )}--happyReduce_189 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_189 = happySpecReduce_0 70# happyReduction_189-happyReduction_189 = happyIn86- (noLoc ([],OpenTypeFamily)- )--happyReduce_190 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_190 = happySpecReduce_2 70# happyReduction_190-happyReduction_190 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut87 happy_x_2 of { happy_var_2 -> - happyIn86- (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)- ,ClosedTypeFamily (fmap reverse $ snd $ unLoc happy_var_2))- )}}--happyReduce_191 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_191 = happySpecReduce_3 71# happyReduction_191-happyReduction_191 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut88 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn87- (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]- ,Just (unLoc happy_var_2))- )}}}--happyReduce_192 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_192 = happySpecReduce_3 71# happyReduction_192-happyReduction_192 happy_x_3- happy_x_2- happy_x_1- = case happyOut88 happy_x_2 of { happy_var_2 -> - happyIn87- (let L loc _ = happy_var_2 in- L loc ([],Just (unLoc happy_var_2))- )}--happyReduce_193 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_193 = happySpecReduce_3 71# happyReduction_193-happyReduction_193 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn87- (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mj AnnDotdot happy_var_2- ,mcc happy_var_3],Nothing)- )}}}--happyReduce_194 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_194 = happySpecReduce_3 71# happyReduction_194-happyReduction_194 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn87- (let L loc _ = happy_var_2 in- L loc ([mj AnnDotdot happy_var_2],Nothing)- )}--happyReduce_195 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_195 = happyMonadReduce 3# 72# happyReduction_195-happyReduction_195 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut88 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut89 happy_x_3 of { happy_var_3 -> - ( asl (unLoc happy_var_1) happy_var_2 (snd $ unLoc happy_var_3)- >> ams happy_var_3 (fst $ unLoc happy_var_3)- >> return (sLL happy_var_1 happy_var_3 ((snd $ unLoc happy_var_3) : unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn88 r))--happyReduce_196 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_196 = happyMonadReduce 2# 72# happyReduction_196-happyReduction_196 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut88 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)- >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})- ) (\r -> happyReturn (happyIn88 r))--happyReduce_197 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_197 = happyMonadReduce 1# 72# happyReduction_197-happyReduction_197 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut89 happy_x_1 of { happy_var_1 -> - ( ams happy_var_1 (fst $ unLoc happy_var_1)- >> return (sLL happy_var_1 happy_var_1 [snd $ unLoc happy_var_1]))})- ) (\r -> happyReturn (happyIn88 r))--happyReduce_198 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_198 = happySpecReduce_0 72# happyReduction_198-happyReduction_198 = happyIn88- (noLoc []- )--happyReduce_199 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_199 = happyMonadReduce 3# 73# happyReduction_199-happyReduction_199 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut155 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut151 happy_x_3 of { happy_var_3 -> - ( do { (eqn,ann) <- mkTyFamInstEqn happy_var_1 happy_var_3- ; return (sLL happy_var_1 happy_var_3 (mj AnnEqual happy_var_2:ann, sLL happy_var_1 happy_var_3 eqn)) })}}})- ) (\r -> happyReturn (happyIn89 r))--happyReduce_200 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_200 = happyMonadReduce 4# 74# happyReduction_200-happyReduction_200 (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 happyOut91 happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_3 of { happy_var_3 -> - case happyOut95 happy_x_4 of { happy_var_4 -> - ( amms (liftM mkTyClD (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) DataFamily happy_var_3- (snd $ unLoc happy_var_4) Nothing))- (mj AnnData happy_var_1:happy_var_2++(fst $ unLoc happy_var_4)))}}}})- ) (\r -> happyReturn (happyIn90 r))--happyReduce_201 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_201 = happyMonadReduce 3# 74# happyReduction_201-happyReduction_201 (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 happyOut155 happy_x_2 of { happy_var_2 -> - case happyOut97 happy_x_3 of { happy_var_3 -> - ( amms (liftM mkTyClD- (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_3) OpenTypeFamily happy_var_2- (fst . snd $ unLoc happy_var_3)- (snd . snd $ unLoc happy_var_3)))- (mj AnnType happy_var_1:(fst $ unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn90 r))--happyReduce_202 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_202 = happyMonadReduce 4# 74# happyReduction_202-happyReduction_202 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_3 of { happy_var_3 -> - case happyOut97 happy_x_4 of { happy_var_4 -> - ( amms (liftM mkTyClD- (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) OpenTypeFamily happy_var_3- (fst . snd $ unLoc happy_var_4)- (snd . snd $ unLoc happy_var_4)))- (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})- ) (\r -> happyReturn (happyIn90 r))--happyReduce_203 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_203 = happyMonadReduce 2# 74# happyReduction_203-happyReduction_203 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut89 happy_x_2 of { happy_var_2 -> - ( ams happy_var_2 (fst $ unLoc happy_var_2) >>- amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_2) (snd $ unLoc happy_var_2)))- (mj AnnType happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn90 r))--happyReduce_204 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_204 = happyMonadReduce 3# 74# happyReduction_204-happyReduction_204 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut89 happy_x_3 of { happy_var_3 -> - ( ams happy_var_3 (fst $ unLoc happy_var_3) >>- amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3)))- (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn90 r))--happyReduce_205 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_205 = happySpecReduce_0 75# happyReduction_205-happyReduction_205 = happyIn91- ([]- )--happyReduce_206 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_206 = happySpecReduce_1 75# happyReduction_206-happyReduction_206 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn91- ([mj AnnFamily happy_var_1]- )}--happyReduce_207 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_207 = happyMonadReduce 2# 76# happyReduction_207-happyReduction_207 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut89 happy_x_2 of { happy_var_2 -> - ( ams happy_var_2 (fst $ unLoc happy_var_2) >>- amms (mkTyFamInst (comb2 happy_var_1 happy_var_2) (snd $ unLoc happy_var_2))- (mj AnnType happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn92 r))--happyReduce_208 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_208 = happyMonadReduce 5# 76# happyReduction_208-happyReduction_208 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut93 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_2 of { happy_var_2 -> - case happyOut98 happy_x_3 of { happy_var_3 -> - case happyOut178 happy_x_4 of { happy_var_4 -> - case happyOut186 happy_x_5 of { happy_var_5 -> - ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3- Nothing (reverse (snd $ unLoc happy_var_4))- (fmap reverse happy_var_5))- ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)))}}}}})- ) (\r -> happyReturn (happyIn92 r))--happyReduce_209 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_209 = happyMonadReduce 6# 76# happyReduction_209-happyReduction_209 (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 happyOut93 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_2 of { happy_var_2 -> - case happyOut98 happy_x_3 of { happy_var_3 -> - case happyOut94 happy_x_4 of { happy_var_4 -> - case happyOut174 happy_x_5 of { happy_var_5 -> - case happyOut186 happy_x_6 of { happy_var_6 -> - ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_3 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_2- happy_var_3 (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)- (fmap reverse happy_var_6))- ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})- ) (\r -> happyReturn (happyIn92 r))--happyReduce_210 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_210 = happySpecReduce_1 77# happyReduction_210-happyReduction_210 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn93- (sL1 happy_var_1 (mj AnnData happy_var_1,DataType)- )}--happyReduce_211 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_211 = happySpecReduce_1 77# happyReduction_211-happyReduction_211 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn93- (sL1 happy_var_1 (mj AnnNewtype happy_var_1,NewType)- )}--happyReduce_212 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_212 = happySpecReduce_0 78# happyReduction_212-happyReduction_212 = happyIn94- (noLoc ([] , Nothing)- )--happyReduce_213 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_213 = happySpecReduce_2 78# happyReduction_213-happyReduction_213 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut173 happy_x_2 of { happy_var_2 -> - happyIn94- (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], Just happy_var_2)- )}}--happyReduce_214 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_214 = happySpecReduce_0 79# happyReduction_214-happyReduction_214 = happyIn95- (noLoc ([] , noLoc NoSig )- )--happyReduce_215 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_215 = happySpecReduce_2 79# happyReduction_215-happyReduction_215 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut173 happy_x_2 of { happy_var_2 -> - happyIn95- (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig happy_var_2))- )}}--happyReduce_216 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_216 = happySpecReduce_0 80# happyReduction_216-happyReduction_216 = happyIn96- (noLoc ([] , noLoc NoSig )- )--happyReduce_217 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_217 = happySpecReduce_2 80# happyReduction_217-happyReduction_217 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut173 happy_x_2 of { happy_var_2 -> - happyIn96- (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig happy_var_2))- )}}--happyReduce_218 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_218 = happySpecReduce_2 80# happyReduction_218-happyReduction_218 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut168 happy_x_2 of { happy_var_2 -> - happyIn96- (sLL happy_var_1 happy_var_2 ([mj AnnEqual happy_var_1] , sLL happy_var_1 happy_var_2 (TyVarSig happy_var_2))- )}}--happyReduce_219 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_219 = happySpecReduce_0 81# happyReduction_219-happyReduction_219 = happyIn97- (noLoc ([], (noLoc NoSig, Nothing))- )--happyReduce_220 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_220 = happySpecReduce_2 81# happyReduction_220-happyReduction_220 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut173 happy_x_2 of { happy_var_2 -> - happyIn97- (sLL happy_var_1 happy_var_2 ( [mu AnnDcolon happy_var_1]- , (sLL happy_var_2 happy_var_2 (KindSig happy_var_2), Nothing))- )}}--happyReduce_221 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_221 = happyReduce 4# 81# happyReduction_221-happyReduction_221 (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 happyOut168 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut84 happy_x_4 of { happy_var_4 -> - happyIn97- (sLL happy_var_1 happy_var_4 ([mj AnnEqual happy_var_1, mj AnnVbar happy_var_3]- , (sLL happy_var_1 happy_var_2 (TyVarSig happy_var_2), Just happy_var_4))- ) `HappyStk` happyRest}}}}--happyReduce_222 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_222 = happyMonadReduce 3# 82# happyReduction_222-happyReduction_222 (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 { happy_var_2 -> - case happyOut155 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)- >> (return (sLL happy_var_1 happy_var_3 (Just happy_var_1, happy_var_3))))}}})- ) (\r -> happyReturn (happyIn98 r))--happyReduce_223 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_223 = happySpecReduce_1 82# happyReduction_223-happyReduction_223 happy_x_1- = case happyOut155 happy_x_1 of { happy_var_1 -> - happyIn98- (sL1 happy_var_1 (Nothing, happy_var_1)- )}--happyReduce_224 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_224 = happyMonadReduce 4# 83# happyReduction_224-happyReduction_224 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ajs (Just (sLL happy_var_1 happy_var_4 (CType (getCTYPEs happy_var_1) (Just (Header (getSTRINGs happy_var_2) (getSTRING happy_var_2)))- (getSTRINGs happy_var_3,getSTRING happy_var_3))))- [mo happy_var_1,mj AnnHeader happy_var_2,mj AnnVal happy_var_3,mc happy_var_4])}}}})- ) (\r -> happyReturn (happyIn99 r))--happyReduce_225 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_225 = happyMonadReduce 3# 83# happyReduction_225-happyReduction_225 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ajs (Just (sLL happy_var_1 happy_var_3 (CType (getCTYPEs happy_var_1) Nothing (getSTRINGs happy_var_2, getSTRING happy_var_2))))- [mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn99 r))--happyReduce_226 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_226 = happySpecReduce_0 83# happyReduction_226-happyReduction_226 = happyIn99- (Nothing- )--happyReduce_227 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_227 = happyMonadReduce 5# 84# happyReduction_227-happyReduction_227 (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 happyOut82 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut81 happy_x_4 of { happy_var_4 -> - case happyOut162 happy_x_5 of { happy_var_5 -> - ( do { let { err = text "in the stand-alone deriving instance"- <> colon <+> quotes (ppr happy_var_5) }- ; ams (sLL happy_var_1 (hsSigType happy_var_5) (DerivDecl happy_var_5 happy_var_2 happy_var_4))- [mj AnnDeriving happy_var_1, mj AnnInstance happy_var_3] })}}}}})- ) (\r -> happyReturn (happyIn100 r))--happyReduce_228 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_228 = happyMonadReduce 4# 85# happyReduction_228-happyReduction_228 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut273 happy_x_3 of { happy_var_3 -> - case happyOut102 happy_x_4 of { happy_var_4 -> - ( amms (mkRoleAnnotDecl (comb3 happy_var_1 happy_var_3 happy_var_4) happy_var_3 (reverse (unLoc happy_var_4)))- [mj AnnType happy_var_1,mj AnnRole happy_var_2])}}}})- ) (\r -> happyReturn (happyIn101 r))--happyReduce_229 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_229 = happySpecReduce_0 86# happyReduction_229-happyReduction_229 = happyIn102- (noLoc []- )--happyReduce_230 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_230 = happySpecReduce_1 86# happyReduction_230-happyReduction_230 happy_x_1- = case happyOut103 happy_x_1 of { happy_var_1 -> - happyIn102- (happy_var_1- )}--happyReduce_231 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_231 = happySpecReduce_1 87# happyReduction_231-happyReduction_231 happy_x_1- = case happyOut104 happy_x_1 of { happy_var_1 -> - happyIn103- (sLL happy_var_1 happy_var_1 [happy_var_1]- )}--happyReduce_232 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_232 = happySpecReduce_2 87# happyReduction_232-happyReduction_232 happy_x_2- happy_x_1- = case happyOut103 happy_x_1 of { happy_var_1 -> - case happyOut104 happy_x_2 of { happy_var_2 -> - happyIn103- (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1- )}}--happyReduce_233 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_233 = happySpecReduce_1 88# happyReduction_233-happyReduction_233 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn104- (sL1 happy_var_1 $ Just $ getVARID happy_var_1- )}--happyReduce_234 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_234 = happySpecReduce_1 88# happyReduction_234-happyReduction_234 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn104- (sL1 happy_var_1 Nothing- )}--happyReduce_235 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-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 { happy_var_1 -> - case happyOut106 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut239 happy_x_4 of { happy_var_4 -> - ( let (name, args,as ) = happy_var_2 in- ams (sLL happy_var_1 happy_var_4 . ValD $ mkPatSynBind name args happy_var_4- ImplicitBidirectional)- (as ++ [mj AnnPattern happy_var_1, mj AnnEqual happy_var_3]))}}}})- ) (\r -> happyReturn (happyIn105 r))--happyReduce_236 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_236 = happyMonadReduce 4# 89# happyReduction_236-happyReduction_236 (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 happyOut106 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut239 happy_x_4 of { happy_var_4 -> - ( let (name, args, as) = happy_var_2 in- ams (sLL happy_var_1 happy_var_4 . ValD $ mkPatSynBind name args happy_var_4 Unidirectional)- (as ++ [mj AnnPattern happy_var_1,mu AnnLarrow happy_var_3]))}}}})- ) (\r -> happyReturn (happyIn105 r))--happyReduce_237 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_237 = happyMonadReduce 5# 89# happyReduction_237-happyReduction_237 (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 happyOut106 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut239 happy_x_4 of { happy_var_4 -> - case happyOut109 happy_x_5 of { happy_var_5 -> - ( do { let (name, args, as) = happy_var_2- ; mg <- mkPatSynMatchGroup name (snd $ unLoc happy_var_5)- ; ams (sLL happy_var_1 happy_var_5 . ValD $- mkPatSynBind name args happy_var_4 (ExplicitBidirectional mg))- (as ++ ((mj AnnPattern happy_var_1:mu AnnLarrow happy_var_3:(fst $ unLoc happy_var_5))) )- })}}}}})- ) (\r -> happyReturn (happyIn105 r))--happyReduce_238 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_238 = happySpecReduce_2 90# happyReduction_238-happyReduction_238 happy_x_2- happy_x_1- = case happyOut265 happy_x_1 of { happy_var_1 -> - case happyOut107 happy_x_2 of { happy_var_2 -> - happyIn106- ((happy_var_1, PrefixPatSyn happy_var_2, [])- )}}--happyReduce_239 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_239 = happySpecReduce_3 90# happyReduction_239-happyReduction_239 happy_x_3- happy_x_2- happy_x_1- = case happyOut293 happy_x_1 of { happy_var_1 -> - case happyOut269 happy_x_2 of { happy_var_2 -> - case happyOut293 happy_x_3 of { happy_var_3 -> - happyIn106- ((happy_var_2, InfixPatSyn happy_var_1 happy_var_3, [])- )}}}--happyReduce_240 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_240 = happyReduce 4# 90# happyReduction_240-happyReduction_240 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut265 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut108 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn106- ((happy_var_1, RecordPatSyn happy_var_3, [moc happy_var_2, mcc happy_var_4] )- ) `HappyStk` happyRest}}}}--happyReduce_241 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_241 = happySpecReduce_0 91# happyReduction_241-happyReduction_241 = happyIn107- ([]- )--happyReduce_242 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_242 = happySpecReduce_2 91# happyReduction_242-happyReduction_242 happy_x_2- happy_x_1- = case happyOut293 happy_x_1 of { happy_var_1 -> - case happyOut107 happy_x_2 of { happy_var_2 -> - happyIn107- (happy_var_1 : happy_var_2- )}}--happyReduce_243 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_243 = happySpecReduce_1 92# happyReduction_243-happyReduction_243 happy_x_1- = case happyOut293 happy_x_1 of { happy_var_1 -> - happyIn108- ([RecordPatSynField happy_var_1 happy_var_1]- )}--happyReduce_244 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_244 = happyMonadReduce 3# 92# happyReduction_244-happyReduction_244 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut293 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut108 happy_x_3 of { happy_var_3 -> - ( addAnnotation (getLoc happy_var_1) AnnComma (getLoc happy_var_2) >>- return ((RecordPatSynField happy_var_1 happy_var_1) : happy_var_3 ))}}})- ) (\r -> happyReturn (happyIn108 r))--happyReduce_245 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_245 = happyReduce 4# 93# happyReduction_245-happyReduction_245 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut119 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn109- (sLL happy_var_1 happy_var_4 ((mj AnnWhere happy_var_1:moc happy_var_2- :mcc happy_var_4:(fst $ unLoc happy_var_3)),sL1 happy_var_3 (snd $ unLoc happy_var_3))- ) `HappyStk` happyRest}}}}--happyReduce_246 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_246 = happyReduce 4# 93# happyReduction_246-happyReduction_246 (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 happyOut119 happy_x_3 of { happy_var_3 -> - happyIn109- (L (comb2 happy_var_1 happy_var_3) ((mj AnnWhere happy_var_1:(fst $ unLoc happy_var_3))- ,sL1 happy_var_3 (snd $ unLoc happy_var_3))- ) `HappyStk` happyRest}}--happyReduce_247 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_247 = happyMonadReduce 4# 94# happyReduction_247-happyReduction_247 (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 happyOut266 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut145 happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $ PatSynSig (unLoc happy_var_2) (mkLHsSigType happy_var_4))- [mj AnnPattern happy_var_1, mu AnnDcolon happy_var_3])}}}})- ) (\r -> happyReturn (happyIn110 r))--happyReduce_248 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_248 = happySpecReduce_1 95# happyReduction_248-happyReduction_248 happy_x_1- = case happyOut90 happy_x_1 of { happy_var_1 -> - happyIn111- (happy_var_1- )}--happyReduce_249 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_249 = happySpecReduce_1 95# happyReduction_249-happyReduction_249 happy_x_1- = case happyOut192 happy_x_1 of { happy_var_1 -> - happyIn111- (happy_var_1- )}--happyReduce_250 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_250 = happyMonadReduce 4# 95# happyReduction_250-happyReduction_250 (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 happyOut201 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut145 happy_x_4 of { happy_var_4 -> - ( do { v <- checkValSigLhs happy_var_2- ; let err = text "in default signature" <> colon <+>- quotes (ppr happy_var_2)- ; ams (sLL happy_var_1 happy_var_4 $ SigD $ ClassOpSig True [v] $ mkLHsSigType happy_var_4)- [mj AnnDefault happy_var_1,mu AnnDcolon happy_var_3] })}}}})- ) (\r -> happyReturn (happyIn111 r))--happyReduce_251 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_251 = happyMonadReduce 3# 96# happyReduction_251-happyReduction_251 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut112 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut111 happy_x_3 of { happy_var_3 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- , unitOL happy_var_3))- else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]- >> return (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1- ,(snd $ unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})- ) (\r -> happyReturn (happyIn112 r))--happyReduce_252 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_252 = happyMonadReduce 2# 96# happyReduction_252-happyReduction_252 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut112 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- ,snd $ unLoc happy_var_1))- else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]- >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})- ) (\r -> happyReturn (happyIn112 r))--happyReduce_253 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_253 = happySpecReduce_1 96# happyReduction_253-happyReduction_253 happy_x_1- = case happyOut111 happy_x_1 of { happy_var_1 -> - happyIn112- (sL1 happy_var_1 ([], unitOL happy_var_1)- )}--happyReduce_254 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_254 = happySpecReduce_0 96# happyReduction_254-happyReduction_254 = happyIn112- (noLoc ([],nilOL)- )--happyReduce_255 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_255 = happySpecReduce_3 97# happyReduction_255-happyReduction_255 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut112 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn113- (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)- ,snd $ unLoc happy_var_2)- )}}}--happyReduce_256 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_256 = happySpecReduce_3 97# happyReduction_256-happyReduction_256 happy_x_3- happy_x_2- happy_x_1- = case happyOut112 happy_x_2 of { happy_var_2 -> - happyIn113- (happy_var_2- )}--happyReduce_257 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_257 = happySpecReduce_2 98# happyReduction_257-happyReduction_257 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut113 happy_x_2 of { happy_var_2 -> - happyIn114- (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)- ,snd $ unLoc happy_var_2)- )}}--happyReduce_258 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_258 = happySpecReduce_0 98# happyReduction_258-happyReduction_258 = happyIn114- (noLoc ([],nilOL)- )--happyReduce_259 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_259 = happySpecReduce_1 99# happyReduction_259-happyReduction_259 happy_x_1- = case happyOut92 happy_x_1 of { happy_var_1 -> - happyIn115- (sLL happy_var_1 happy_var_1 (unitOL (sL1 happy_var_1 (InstD (unLoc happy_var_1))))- )}--happyReduce_260 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_260 = happySpecReduce_1 99# happyReduction_260-happyReduction_260 happy_x_1- = case happyOut192 happy_x_1 of { happy_var_1 -> - happyIn115- (sLL happy_var_1 happy_var_1 (unitOL happy_var_1)- )}--happyReduce_261 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_261 = happyMonadReduce 3# 100# happyReduction_261-happyReduction_261 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut116 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut115 happy_x_3 of { happy_var_3 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- , unLoc happy_var_3))- else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]- >> return- (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1- ,(snd $ unLoc happy_var_1) `appOL` unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn116 r))--happyReduce_262 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_262 = happyMonadReduce 2# 100# happyReduction_262-happyReduction_262 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut116 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- ,snd $ unLoc happy_var_1))- else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]- >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})- ) (\r -> happyReturn (happyIn116 r))--happyReduce_263 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_263 = happySpecReduce_1 100# happyReduction_263-happyReduction_263 happy_x_1- = case happyOut115 happy_x_1 of { happy_var_1 -> - happyIn116- (sL1 happy_var_1 ([],unLoc happy_var_1)- )}--happyReduce_264 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_264 = happySpecReduce_0 100# happyReduction_264-happyReduction_264 = happyIn116- (noLoc ([],nilOL)- )--happyReduce_265 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_265 = happySpecReduce_3 101# happyReduction_265-happyReduction_265 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut116 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn117- (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2),snd $ unLoc happy_var_2)- )}}}--happyReduce_266 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_266 = happySpecReduce_3 101# happyReduction_266-happyReduction_266 happy_x_3- happy_x_2- happy_x_1- = case happyOut116 happy_x_2 of { happy_var_2 -> - happyIn117- (L (gl happy_var_2) (unLoc happy_var_2)- )}--happyReduce_267 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_267 = happySpecReduce_2 102# happyReduction_267-happyReduction_267 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut117 happy_x_2 of { happy_var_2 -> - happyIn118- (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)- ,(snd $ unLoc happy_var_2))- )}}--happyReduce_268 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_268 = happySpecReduce_0 102# happyReduction_268-happyReduction_268 = happyIn118- (noLoc ([],nilOL)- )--happyReduce_269 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_269 = happyMonadReduce 3# 103# happyReduction_269-happyReduction_269 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut119 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut192 happy_x_3 of { happy_var_3 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- , unitOL happy_var_3))- else do ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]- >> return (- let { this = unitOL happy_var_3;- rest = snd $ unLoc happy_var_1;- these = rest `appOL` this }- in rest `seq` this `seq` these `seq`- (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,these))))}}})- ) (\r -> happyReturn (happyIn119 r))--happyReduce_270 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_270 = happyMonadReduce 2# 103# happyReduction_270-happyReduction_270 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut119 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- ,snd $ unLoc happy_var_1)))- else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]- >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})- ) (\r -> happyReturn (happyIn119 r))--happyReduce_271 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_271 = happySpecReduce_1 103# happyReduction_271-happyReduction_271 happy_x_1- = case happyOut192 happy_x_1 of { happy_var_1 -> - happyIn119- (sL1 happy_var_1 ([], unitOL happy_var_1)- )}--happyReduce_272 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_272 = happySpecReduce_0 103# happyReduction_272-happyReduction_272 = happyIn119- (noLoc ([],nilOL)- )--happyReduce_273 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_273 = happySpecReduce_3 104# happyReduction_273-happyReduction_273 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut119 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn120- (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)- ,sL1 happy_var_2 $ snd $ unLoc happy_var_2)- )}}}--happyReduce_274 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_274 = happySpecReduce_3 104# happyReduction_274-happyReduction_274 happy_x_3- happy_x_2- happy_x_1- = case happyOut119 happy_x_2 of { happy_var_2 -> - happyIn120- (L (gl happy_var_2) (fst $ unLoc happy_var_2,sL1 happy_var_2 $ snd $ unLoc happy_var_2)- )}--happyReduce_275 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_275 = happyMonadReduce 1# 105# happyReduction_275-happyReduction_275 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut120 happy_x_1 of { happy_var_1 -> - ( do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc happy_var_1)- ; return (sL1 happy_var_1 (fst $ unLoc happy_var_1- ,sL1 happy_var_1 $ HsValBinds val_binds)) })})- ) (\r -> happyReturn (happyIn121 r))--happyReduce_276 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_276 = happySpecReduce_3 105# happyReduction_276-happyReduction_276 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut251 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn121- (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]- ,sL1 happy_var_2 $ HsIPBinds (IPBinds (reverse $ unLoc happy_var_2)- emptyTcEvBinds))- )}}}--happyReduce_277 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_277 = happySpecReduce_3 105# happyReduction_277-happyReduction_277 happy_x_3- happy_x_2- happy_x_1- = case happyOut251 happy_x_2 of { happy_var_2 -> - happyIn121- (L (getLoc happy_var_2) ([]- ,sL1 happy_var_2 $ HsIPBinds (IPBinds (reverse $ unLoc happy_var_2)- emptyTcEvBinds))- )}--happyReduce_278 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_278 = happySpecReduce_2 106# happyReduction_278-happyReduction_278 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut121 happy_x_2 of { happy_var_2 -> - happyIn122- (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1 : (fst $ unLoc happy_var_2)- ,snd $ unLoc happy_var_2)- )}}--happyReduce_279 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_279 = happySpecReduce_0 106# happyReduction_279-happyReduction_279 = happyIn122- (noLoc ([],noLoc emptyLocalBinds)- )--happyReduce_280 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_280 = happyMonadReduce 3# 107# happyReduction_280-happyReduction_280 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut123 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)- >> return (happy_var_1 `snocOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn123 r))--happyReduce_281 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_281 = happyMonadReduce 2# 107# happyReduction_281-happyReduction_281 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut123 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)- >> return happy_var_1)}})- ) (\r -> happyReturn (happyIn123 r))--happyReduce_282 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_282 = happySpecReduce_1 107# happyReduction_282-happyReduction_282 happy_x_1- = case happyOut124 happy_x_1 of { happy_var_1 -> - happyIn123- (unitOL happy_var_1- )}--happyReduce_283 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_283 = happySpecReduce_0 107# happyReduction_283-happyReduction_283 = happyIn123- (nilOL- )--happyReduce_284 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_284 = happyMonadReduce 6# 108# happyReduction_284-happyReduction_284 (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 happyOut125 happy_x_2 of { happy_var_2 -> - case happyOut127 happy_x_3 of { happy_var_3 -> - case happyOut201 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut200 happy_x_6 of { happy_var_6 -> - (ams (sLL happy_var_1 happy_var_6 $ (HsRule (L (gl happy_var_1) (getSTRINGs happy_var_1,getSTRING happy_var_1))- ((snd happy_var_2) `orElse` AlwaysActive)- (snd happy_var_3) happy_var_4 placeHolderNames happy_var_6- placeHolderNames))- (mj AnnEqual happy_var_5 : (fst happy_var_2) ++ (fst happy_var_3)))}}}}}})- ) (\r -> happyReturn (happyIn124 r))--happyReduce_285 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_285 = happySpecReduce_0 109# happyReduction_285-happyReduction_285 = happyIn125- (([],Nothing)- )--happyReduce_286 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_286 = happySpecReduce_1 109# happyReduction_286-happyReduction_286 happy_x_1- = case happyOut126 happy_x_1 of { happy_var_1 -> - happyIn125- ((fst happy_var_1,Just (snd happy_var_1))- )}--happyReduce_287 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_287 = happySpecReduce_3 110# happyReduction_287-happyReduction_287 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn126- (([mos happy_var_1,mj AnnVal happy_var_2,mcs happy_var_3]- ,ActiveAfter (getINTEGERs happy_var_2) (fromInteger (getINTEGER happy_var_2)))- )}}}--happyReduce_288 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_288 = happyReduce 4# 110# happyReduction_288-happyReduction_288 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn126- (([mos happy_var_1,mj AnnTilde happy_var_2,mj AnnVal happy_var_3,mcs happy_var_4]- ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (getINTEGER happy_var_3)))- ) `HappyStk` happyRest}}}}--happyReduce_289 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_289 = happySpecReduce_3 110# happyReduction_289-happyReduction_289 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn126- (([mos happy_var_1,mj AnnTilde happy_var_2,mcs happy_var_3]- ,NeverActive)- )}}}--happyReduce_290 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_290 = happySpecReduce_3 111# happyReduction_290-happyReduction_290 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut128 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn127- (([mu AnnForall happy_var_1,mj AnnDot happy_var_3],happy_var_2)- )}}}--happyReduce_291 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_291 = happySpecReduce_0 111# happyReduction_291-happyReduction_291 = happyIn127- (([],[])- )--happyReduce_292 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_292 = happySpecReduce_1 112# happyReduction_292-happyReduction_292 happy_x_1- = case happyOut129 happy_x_1 of { happy_var_1 -> - happyIn128- ([happy_var_1]- )}--happyReduce_293 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_293 = happySpecReduce_2 112# happyReduction_293-happyReduction_293 happy_x_2- happy_x_1- = case happyOut129 happy_x_1 of { happy_var_1 -> - case happyOut128 happy_x_2 of { happy_var_2 -> - happyIn128- (happy_var_1 : happy_var_2- )}}--happyReduce_294 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_294 = happySpecReduce_1 113# happyReduction_294-happyReduction_294 happy_x_1- = case happyOut293 happy_x_1 of { happy_var_1 -> - happyIn129- (sLL happy_var_1 happy_var_1 (RuleBndr happy_var_1)- )}--happyReduce_295 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_295 = happyMonadReduce 5# 113# happyReduction_295-happyReduction_295 (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 happyOut293 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut151 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( ams (sLL happy_var_1 happy_var_5 (RuleBndrSig happy_var_2- (mkLHsSigWcType happy_var_4)))- [mop happy_var_1,mu AnnDcolon happy_var_3,mcp happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn129 r))--happyReduce_296 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_296 = happyMonadReduce 3# 114# happyReduction_296-happyReduction_296 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut130 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut131 happy_x_3 of { happy_var_3 -> - ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)- >> return (happy_var_1 `appOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn130 r))--happyReduce_297 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_297 = happyMonadReduce 2# 114# happyReduction_297-happyReduction_297 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut130 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)- >> return happy_var_1)}})- ) (\r -> happyReturn (happyIn130 r))--happyReduce_298 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_298 = happySpecReduce_1 114# happyReduction_298-happyReduction_298 happy_x_1- = case happyOut131 happy_x_1 of { happy_var_1 -> - happyIn130- (happy_var_1- )}--happyReduce_299 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_299 = happySpecReduce_0 114# happyReduction_299-happyReduction_299 = happyIn130- (nilOL- )--happyReduce_300 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_300 = happyMonadReduce 2# 115# happyReduction_300-happyReduction_300 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut260 happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_2 of { happy_var_2 -> - ( amsu (sLL happy_var_1 happy_var_2 (Warning (unLoc happy_var_1) (WarningTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))- (fst $ unLoc happy_var_2))}})- ) (\r -> happyReturn (happyIn131 r))--happyReduce_301 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_301 = happyMonadReduce 3# 116# happyReduction_301-happyReduction_301 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut132 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut133 happy_x_3 of { happy_var_3 -> - ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)- >> return (happy_var_1 `appOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn132 r))--happyReduce_302 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_302 = happyMonadReduce 2# 116# happyReduction_302-happyReduction_302 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut132 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)- >> return happy_var_1)}})- ) (\r -> happyReturn (happyIn132 r))--happyReduce_303 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_303 = happySpecReduce_1 116# happyReduction_303-happyReduction_303 happy_x_1- = case happyOut133 happy_x_1 of { happy_var_1 -> - happyIn132- (happy_var_1- )}--happyReduce_304 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_304 = happySpecReduce_0 116# happyReduction_304-happyReduction_304 = happyIn132- (nilOL- )--happyReduce_305 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_305 = happyMonadReduce 2# 117# happyReduction_305-happyReduction_305 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut260 happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_2 of { happy_var_2 -> - ( amsu (sLL happy_var_1 happy_var_2 $ (Warning (unLoc happy_var_1) (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))- (fst $ unLoc happy_var_2))}})- ) (\r -> happyReturn (happyIn133 r))--happyReduce_306 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_306 = happySpecReduce_1 118# happyReduction_306-happyReduction_306 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn134- (sL1 happy_var_1 ([],[L (gl happy_var_1) (getStringLiteral happy_var_1)])- )}--happyReduce_307 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_307 = happySpecReduce_3 118# happyReduction_307-happyReduction_307 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut135 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn134- (sLL happy_var_1 happy_var_3 $ ([mos happy_var_1,mcs happy_var_3],fromOL (unLoc happy_var_2))- )}}}--happyReduce_308 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_308 = happyMonadReduce 3# 119# happyReduction_308-happyReduction_308 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut135 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 (unLoc happy_var_1 `snocOL`- (L (gl happy_var_3) (getStringLiteral happy_var_3)))))}}})- ) (\r -> happyReturn (happyIn135 r))--happyReduce_309 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_309 = happySpecReduce_1 119# happyReduction_309-happyReduction_309 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn135- (sLL happy_var_1 happy_var_1 (unitOL (L (gl happy_var_1) (getStringLiteral happy_var_1)))- )}--happyReduce_310 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_310 = happySpecReduce_0 119# happyReduction_310-happyReduction_310 = happyIn135- (noLoc nilOL- )--happyReduce_311 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_311 = happyMonadReduce 4# 120# happyReduction_311-happyReduction_311 (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 happyOut261 happy_x_2 of { happy_var_2 -> - case happyOut209 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 (AnnD $ HsAnnotation- (getANN_PRAGs happy_var_1)- (ValueAnnProvenance happy_var_2) happy_var_3))- [mo happy_var_1,mc happy_var_4])}}}})- ) (\r -> happyReturn (happyIn136 r))--happyReduce_312 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_312 = happyMonadReduce 5# 120# happyReduction_312-happyReduction_312 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut278 happy_x_3 of { happy_var_3 -> - case happyOut209 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( ams (sLL happy_var_1 happy_var_5 (AnnD $ HsAnnotation- (getANN_PRAGs happy_var_1)- (TypeAnnProvenance happy_var_3) happy_var_4))- [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn136 r))--happyReduce_313 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_313 = happyMonadReduce 4# 120# happyReduction_313-happyReduction_313 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut209 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 (AnnD $ HsAnnotation- (getANN_PRAGs happy_var_1)- ModuleAnnProvenance happy_var_3))- [mo happy_var_1,mj AnnModule happy_var_2,mc happy_var_4])}}}})- ) (\r -> happyReturn (happyIn136 r))--happyReduce_314 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_314 = happyMonadReduce 4# 121# happyReduction_314-happyReduction_314 (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 happyOut138 happy_x_2 of { happy_var_2 -> - case happyOut139 happy_x_3 of { happy_var_3 -> - case happyOut140 happy_x_4 of { happy_var_4 -> - ( mkImport happy_var_2 happy_var_3 (snd $ unLoc happy_var_4) >>= \i ->- return (sLL happy_var_1 happy_var_4 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_4),i)))}}}})- ) (\r -> happyReturn (happyIn137 r))--happyReduce_315 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_315 = happyMonadReduce 3# 121# happyReduction_315-happyReduction_315 (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 happyOut138 happy_x_2 of { happy_var_2 -> - case happyOut140 happy_x_3 of { happy_var_3 -> - ( do { d <- mkImport happy_var_2 (noLoc PlaySafe) (snd $ unLoc happy_var_3);- return (sLL happy_var_1 happy_var_3 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_3),d)) })}}})- ) (\r -> happyReturn (happyIn137 r))--happyReduce_316 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_316 = happyMonadReduce 3# 121# happyReduction_316-happyReduction_316 (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 happyOut138 happy_x_2 of { happy_var_2 -> - case happyOut140 happy_x_3 of { happy_var_3 -> - ( mkExport happy_var_2 (snd $ unLoc happy_var_3) >>= \i ->- return (sLL happy_var_1 happy_var_3 (mj AnnExport happy_var_1 : (fst $ unLoc happy_var_3),i) ))}}})- ) (\r -> happyReturn (happyIn137 r))--happyReduce_317 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_317 = happySpecReduce_1 122# happyReduction_317-happyReduction_317 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn138- (sLL happy_var_1 happy_var_1 StdCallConv- )}--happyReduce_318 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_318 = happySpecReduce_1 122# happyReduction_318-happyReduction_318 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn138- (sLL happy_var_1 happy_var_1 CCallConv- )}--happyReduce_319 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_319 = happySpecReduce_1 122# happyReduction_319-happyReduction_319 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn138- (sLL happy_var_1 happy_var_1 CApiConv- )}--happyReduce_320 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_320 = happySpecReduce_1 122# happyReduction_320-happyReduction_320 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn138- (sLL happy_var_1 happy_var_1 PrimCallConv- )}--happyReduce_321 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_321 = happySpecReduce_1 122# happyReduction_321-happyReduction_321 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn138- (sLL happy_var_1 happy_var_1 JavaScriptCallConv- )}--happyReduce_322 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_322 = happySpecReduce_1 123# happyReduction_322-happyReduction_322 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn139- (sLL happy_var_1 happy_var_1 PlayRisky- )}--happyReduce_323 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_323 = happySpecReduce_1 123# happyReduction_323-happyReduction_323 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn139- (sLL happy_var_1 happy_var_1 PlaySafe- )}--happyReduce_324 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_324 = happySpecReduce_1 123# happyReduction_324-happyReduction_324 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn139- (sLL happy_var_1 happy_var_1 PlayInterruptible- )}--happyReduce_325 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_325 = happyReduce 4# 124# happyReduction_325-happyReduction_325 (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 happyOut290 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut145 happy_x_4 of { happy_var_4 -> - happyIn140- (sLL happy_var_1 happy_var_4 ([mu AnnDcolon happy_var_3]- ,(L (getLoc happy_var_1)- (getStringLiteral happy_var_1), happy_var_2, mkLHsSigType happy_var_4))- ) `HappyStk` happyRest}}}}--happyReduce_326 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_326 = happySpecReduce_3 124# happyReduction_326-happyReduction_326 happy_x_3- happy_x_2- happy_x_1- = case happyOut290 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut145 happy_x_3 of { happy_var_3 -> - happyIn140- (sLL happy_var_1 happy_var_3 ([mu AnnDcolon happy_var_2]- ,(noLoc (StringLiteral NoSourceText nilFS), happy_var_1, mkLHsSigType happy_var_3))- )}}}--happyReduce_327 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_327 = happySpecReduce_0 125# happyReduction_327-happyReduction_327 = happyIn141- (([],Nothing)- )--happyReduce_328 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_328 = happySpecReduce_2 125# happyReduction_328-happyReduction_328 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut144 happy_x_2 of { happy_var_2 -> - happyIn141- (([mu AnnDcolon happy_var_1],Just happy_var_2)- )}}--happyReduce_329 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_329 = happySpecReduce_0 126# happyReduction_329-happyReduction_329 = happyIn142- (([],Nothing)- )--happyReduce_330 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_330 = happySpecReduce_2 126# happyReduction_330-happyReduction_330 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut161 happy_x_2 of { happy_var_2 -> - happyIn142- (([mu AnnDcolon happy_var_1],Just happy_var_2)- )}}--happyReduce_331 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_331 = happySpecReduce_0 127# happyReduction_331-happyReduction_331 = happyIn143- (([], Nothing)- )--happyReduce_332 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_332 = happySpecReduce_2 127# happyReduction_332-happyReduction_332 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut271 happy_x_2 of { happy_var_2 -> - happyIn143- (([mu AnnDcolon happy_var_1], Just happy_var_2)- )}}--happyReduce_333 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_333 = happySpecReduce_1 128# happyReduction_333-happyReduction_333 happy_x_1- = case happyOut151 happy_x_1 of { happy_var_1 -> - happyIn144- (happy_var_1- )}--happyReduce_334 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_334 = happySpecReduce_1 129# happyReduction_334-happyReduction_334 happy_x_1- = case happyOut152 happy_x_1 of { happy_var_1 -> - happyIn145- (happy_var_1- )}--happyReduce_335 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_335 = happyMonadReduce 3# 130# happyReduction_335-happyReduction_335 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut146 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut290 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1)- AnnComma (gl happy_var_2)- >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn146 r))--happyReduce_336 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_336 = happySpecReduce_1 130# happyReduction_336-happyReduction_336 happy_x_1- = case happyOut290 happy_x_1 of { happy_var_1 -> - happyIn146- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_337 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_337 = happySpecReduce_1 131# happyReduction_337-happyReduction_337 happy_x_1- = case happyOut144 happy_x_1 of { happy_var_1 -> - happyIn147- (unitOL (mkLHsSigType happy_var_1)- )}--happyReduce_338 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_338 = happyMonadReduce 3# 131# happyReduction_338-happyReduction_338 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut144 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut147 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)- >> return (unitOL (mkLHsSigType happy_var_1) `appOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn147 r))--happyReduce_339 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_339 = happySpecReduce_1 132# happyReduction_339-happyReduction_339 happy_x_1- = case happyOut149 happy_x_1 of { happy_var_1 -> - happyIn148- (sL1 happy_var_1 (let (a, str) = unLoc happy_var_1 in (a, HsSrcBang NoSourceText NoSrcUnpack str))- )}--happyReduce_340 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_340 = happySpecReduce_1 132# happyReduction_340-happyReduction_340 happy_x_1- = case happyOut150 happy_x_1 of { happy_var_1 -> - happyIn148- (sL1 happy_var_1 (let (a, prag, unpk) = unLoc happy_var_1 in (a, HsSrcBang prag unpk NoSrcStrict))- )}--happyReduce_341 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_341 = happySpecReduce_2 132# happyReduction_341-happyReduction_341 happy_x_2- happy_x_1- = case happyOut150 happy_x_1 of { happy_var_1 -> - case happyOut149 happy_x_2 of { happy_var_2 -> - happyIn148- (sLL happy_var_1 happy_var_2 (let { (a, prag, unpk) = unLoc happy_var_1- ; (a', str) = unLoc happy_var_2 }- in (a ++ a', HsSrcBang prag unpk str))- )}}--happyReduce_342 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_342 = happySpecReduce_1 133# happyReduction_342-happyReduction_342 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn149- (sL1 happy_var_1 ([mj AnnBang happy_var_1], SrcStrict)- )}--happyReduce_343 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_343 = happySpecReduce_1 133# happyReduction_343-happyReduction_343 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn149- (sL1 happy_var_1 ([mj AnnTilde happy_var_1], SrcLazy)- )}--happyReduce_344 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_344 = happySpecReduce_2 134# happyReduction_344-happyReduction_344 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn150- (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getUNPACK_PRAGs happy_var_1, SrcUnpack)- )}}--happyReduce_345 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_345 = happySpecReduce_2 134# happyReduction_345-happyReduction_345 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn150- (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getNOUNPACK_PRAGs happy_var_1, SrcNoUnpack)- )}}--happyReduce_346 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_346 = happyMonadReduce 4# 135# happyReduction_346-happyReduction_346 (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 happyOut167 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut151 happy_x_4 of { happy_var_4 -> - ( hintExplicitForall (getLoc happy_var_1) >>- ams (sLL happy_var_1 happy_var_4 $- HsForAllTy { hst_bndrs = happy_var_2- , hst_body = happy_var_4 })- [mu AnnForall happy_var_1, mj AnnDot happy_var_3])}}}})- ) (\r -> happyReturn (happyIn151 r))--happyReduce_347 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_347 = happyMonadReduce 3# 135# happyReduction_347-happyReduction_347 (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 { happy_var_2 -> - case happyOut151 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)- >> return (sLL happy_var_1 happy_var_3 $- HsQualTy { hst_ctxt = happy_var_1- , hst_body = happy_var_3 }))}}})- ) (\r -> happyReturn (happyIn151 r))--happyReduce_348 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_348 = happyMonadReduce 3# 135# happyReduction_348-happyReduction_348 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut253 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (HsIParamTy happy_var_1 happy_var_3))- [mu AnnDcolon happy_var_2])}}})- ) (\r -> happyReturn (happyIn151 r))--happyReduce_349 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_349 = happySpecReduce_1 135# happyReduction_349-happyReduction_349 happy_x_1- = case happyOut155 happy_x_1 of { happy_var_1 -> - happyIn151- (happy_var_1- )}--happyReduce_350 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_350 = happyMonadReduce 4# 136# happyReduction_350-happyReduction_350 (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 happyOut167 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut152 happy_x_4 of { happy_var_4 -> - ( hintExplicitForall (getLoc happy_var_1) >>- ams (sLL happy_var_1 happy_var_4 $- HsForAllTy { hst_bndrs = happy_var_2- , hst_body = happy_var_4 })- [mu AnnForall happy_var_1,mj AnnDot happy_var_3])}}}})- ) (\r -> happyReturn (happyIn152 r))--happyReduce_351 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_351 = happyMonadReduce 3# 136# happyReduction_351-happyReduction_351 (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 { happy_var_2 -> - case happyOut152 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)- >> return (sLL happy_var_1 happy_var_3 $- HsQualTy { hst_ctxt = happy_var_1- , hst_body = happy_var_3 }))}}})- ) (\r -> happyReturn (happyIn152 r))--happyReduce_352 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_352 = happyMonadReduce 3# 136# happyReduction_352-happyReduction_352 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut253 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (HsIParamTy happy_var_1 happy_var_3))- [mu AnnDcolon happy_var_2])}}})- ) (\r -> happyReturn (happyIn152 r))--happyReduce_353 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_353 = happySpecReduce_1 136# happyReduction_353-happyReduction_353 happy_x_1- = case happyOut156 happy_x_1 of { happy_var_1 -> - happyIn152- (happy_var_1- )}--happyReduce_354 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_354 = happyMonadReduce 1# 137# happyReduction_354-happyReduction_354 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> - ( do { (anns,ctx) <- checkContext happy_var_1- ; if null (unLoc ctx)- then addAnnotation (gl happy_var_1) AnnUnit (gl happy_var_1)- else return ()- ; ams ctx anns- })})- ) (\r -> happyReturn (happyIn153 r))--happyReduce_355 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_355 = happyMonadReduce 1# 138# happyReduction_355-happyReduction_355 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut158 happy_x_1 of { happy_var_1 -> - ( do { ty <- splitTilde happy_var_1- ; (anns,ctx) <- checkContext ty- ; if null (unLoc ctx)- then addAnnotation (gl ty) AnnUnit (gl ty)- else return ()- ; ams ctx anns- })})- ) (\r -> happyReturn (happyIn154 r))--happyReduce_356 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_356 = happySpecReduce_1 139# happyReduction_356-happyReduction_356 happy_x_1- = case happyOut157 happy_x_1 of { happy_var_1 -> - happyIn155- (happy_var_1- )}--happyReduce_357 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_357 = happyMonadReduce 3# 139# happyReduction_357-happyReduction_357 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut151 happy_x_3 of { happy_var_3 -> - ( ams happy_var_1 [mu AnnRarrow happy_var_2] -- See note [GADT decl discards annotations]- >> ams (sLL happy_var_1 happy_var_3 $ HsFunTy happy_var_1 happy_var_3)- [mu AnnRarrow happy_var_2])}}})- ) (\r -> happyReturn (happyIn155 r))--happyReduce_358 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_358 = happySpecReduce_1 140# happyReduction_358-happyReduction_358 happy_x_1- = case happyOut157 happy_x_1 of { happy_var_1 -> - happyIn156- (happy_var_1- )}--happyReduce_359 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_359 = happySpecReduce_2 140# happyReduction_359-happyReduction_359 happy_x_2- happy_x_1- = case happyOut157 happy_x_1 of { happy_var_1 -> - case happyOut312 happy_x_2 of { happy_var_2 -> - happyIn156- (sLL happy_var_1 happy_var_2 $ HsDocTy happy_var_1 happy_var_2- )}}--happyReduce_360 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_360 = happyMonadReduce 3# 140# happyReduction_360-happyReduction_360 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut152 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsFunTy happy_var_1 happy_var_3)- [mu AnnRarrow happy_var_2])}}})- ) (\r -> happyReturn (happyIn156 r))--happyReduce_361 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_361 = happyMonadReduce 4# 140# happyReduction_361-happyReduction_361 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> - case happyOut312 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut152 happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $- HsFunTy (L (comb2 happy_var_1 happy_var_2) (HsDocTy happy_var_1 happy_var_2))- happy_var_4)- [mu AnnRarrow happy_var_3])}}}})- ) (\r -> happyReturn (happyIn156 r))--happyReduce_362 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_362 = happyMonadReduce 1# 141# happyReduction_362-happyReduction_362 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut159 happy_x_1 of { happy_var_1 -> - ( splitTildeApps (reverse (unLoc happy_var_1)) >>=- \ts -> return $ sL1 happy_var_1 $ HsAppsTy ts)})- ) (\r -> happyReturn (happyIn157 r))--happyReduce_363 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_363 = happySpecReduce_2 142# happyReduction_363-happyReduction_363 happy_x_2- happy_x_1- = case happyOut158 happy_x_1 of { happy_var_1 -> - case happyOut161 happy_x_2 of { happy_var_2 -> - happyIn158- (sLL happy_var_1 happy_var_2 $ HsAppTy happy_var_1 happy_var_2- )}}--happyReduce_364 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_364 = happySpecReduce_1 142# happyReduction_364-happyReduction_364 happy_x_1- = case happyOut161 happy_x_1 of { happy_var_1 -> - happyIn158- (happy_var_1- )}--happyReduce_365 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_365 = happySpecReduce_1 143# happyReduction_365-happyReduction_365 happy_x_1- = case happyOut160 happy_x_1 of { happy_var_1 -> - happyIn159- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_366 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_366 = happySpecReduce_2 143# happyReduction_366-happyReduction_366 happy_x_2- happy_x_1- = case happyOut159 happy_x_1 of { happy_var_1 -> - case happyOut160 happy_x_2 of { happy_var_2 -> - happyIn159- (sLL happy_var_1 happy_var_2 $ happy_var_2 : (unLoc happy_var_1)- )}}--happyReduce_367 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_367 = happySpecReduce_1 144# happyReduction_367-happyReduction_367 happy_x_1- = case happyOut161 happy_x_1 of { happy_var_1 -> - happyIn160- (sL1 happy_var_1 $ HsAppPrefix happy_var_1- )}--happyReduce_368 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_368 = happySpecReduce_1 144# happyReduction_368-happyReduction_368 happy_x_1- = case happyOut275 happy_x_1 of { happy_var_1 -> - happyIn160- (sL1 happy_var_1 $ HsAppInfix happy_var_1- )}--happyReduce_369 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_369 = happySpecReduce_1 144# happyReduction_369-happyReduction_369 happy_x_1- = case happyOut288 happy_x_1 of { happy_var_1 -> - happyIn160- (sL1 happy_var_1 $ HsAppInfix happy_var_1- )}--happyReduce_370 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_370 = happyMonadReduce 2# 144# happyReduction_370-happyReduction_370 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut270 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsAppInfix happy_var_2)- [mj AnnSimpleQuote happy_var_1])}})- ) (\r -> happyReturn (happyIn160 r))--happyReduce_371 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_371 = happyMonadReduce 2# 144# happyReduction_371-happyReduction_371 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut282 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsAppInfix happy_var_2)- [mj AnnSimpleQuote happy_var_1])}})- ) (\r -> happyReturn (happyIn160 r))--happyReduce_372 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_372 = happySpecReduce_1 145# happyReduction_372-happyReduction_372 happy_x_1- = case happyOut272 happy_x_1 of { happy_var_1 -> - happyIn161- (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)- )}--happyReduce_373 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_373 = happySpecReduce_1 145# happyReduction_373-happyReduction_373 happy_x_1- = case happyOut287 happy_x_1 of { happy_var_1 -> - happyIn161- (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)- )}--happyReduce_374 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_374 = happyMonadReduce 2# 145# happyReduction_374-happyReduction_374 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut148 happy_x_1 of { happy_var_1 -> - case happyOut161 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 (HsBangTy (snd $ unLoc happy_var_1) happy_var_2))- (fst $ unLoc happy_var_1))}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_375 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_375 = happyMonadReduce 3# 145# happyReduction_375-happyReduction_375 (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 happyOut183 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amms (checkRecordSyntax- (sLL happy_var_1 happy_var_3 $ HsRecTy happy_var_2))- -- Constructor sigs only- [moc happy_var_1,mcc happy_var_3])}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_376 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_376 = happyMonadReduce 2# 145# happyReduction_376-happyReduction_376 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy- HsBoxedOrConstraintTuple [])- [mop happy_var_1,mcp happy_var_2])}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_377 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_377 = happyMonadReduce 5# 145# happyReduction_377-happyReduction_377 (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 happyOut151 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut165 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( addAnnotation (gl happy_var_2) AnnComma- (gl happy_var_3) >>- ams (sLL happy_var_1 happy_var_5 $ HsTupleTy- HsBoxedOrConstraintTuple (happy_var_2 : happy_var_4))- [mop happy_var_1,mcp happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_378 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_378 = happyMonadReduce 2# 145# happyReduction_378-happyReduction_378 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy HsUnboxedTuple [])- [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_379 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_379 = happyMonadReduce 3# 145# 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 { happy_var_1 -> - case happyOut165 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsTupleTy HsUnboxedTuple happy_var_2)- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_380 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_380 = happyMonadReduce 3# 145# happyReduction_380-happyReduction_380 (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 happyOut166 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsSumTy happy_var_2)- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_381 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_381 = happyMonadReduce 3# 145# happyReduction_381-happyReduction_381 (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 happyOut151 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsListTy happy_var_2) [mos happy_var_1,mcs happy_var_3])}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_382 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_382 = happyMonadReduce 3# 145# happyReduction_382-happyReduction_382 (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 happyOut151 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsPArrTy happy_var_2) [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_383 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_383 = happyMonadReduce 3# 145# happyReduction_383-happyReduction_383 (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 happyOut151 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsParTy happy_var_2) [mop happy_var_1,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_384 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_384 = happyMonadReduce 5# 145# happyReduction_384-happyReduction_384 (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 happyOut151 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut173 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( ams (sLL happy_var_1 happy_var_5 $ HsKindSig happy_var_2 happy_var_4)- [mop happy_var_1,mu AnnDcolon happy_var_3,mcp happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_385 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_385 = happySpecReduce_1 145# happyReduction_385-happyReduction_385 happy_x_1- = case happyOut199 happy_x_1 of { happy_var_1 -> - happyIn161- (sL1 happy_var_1 (HsSpliceTy (unLoc happy_var_1) placeHolderKind)- )}--happyReduce_386 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_386 = happyMonadReduce 3# 145# happyReduction_386-happyReduction_386 (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 happyOut200 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ mkHsSpliceTy HasParens happy_var_2)- [mj AnnOpenPE happy_var_1,mj AnnCloseP happy_var_3])}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_387 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_387 = happyMonadReduce 1# 145# happyReduction_387-happyReduction_387 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - (ams (sLL happy_var_1 happy_var_1 $ mkHsSpliceTy HasDollar $ sL1 happy_var_1 $ HsVar $- (sL1 happy_var_1 (mkUnqual varName (getTH_ID_SPLICE happy_var_1))))- [mj AnnThIdSplice happy_var_1])})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_388 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_388 = happyMonadReduce 2# 145# happyReduction_388-happyReduction_388 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut262 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsTyVar Promoted happy_var_2) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_389 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_389 = happyMonadReduce 6# 145# happyReduction_389-happyReduction_389 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut151 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut165 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( addAnnotation (gl happy_var_3) AnnComma (gl happy_var_4) >>- ams (sLL happy_var_1 happy_var_6 $ HsExplicitTupleTy [] (happy_var_3 : happy_var_5))- [mj AnnSimpleQuote happy_var_1,mop happy_var_2,mcp happy_var_6])}}}}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_390 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_390 = happyMonadReduce 4# 145# happyReduction_390-happyReduction_390 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut164 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $ HsExplicitListTy Promoted- placeHolderKind happy_var_3)- [mj AnnSimpleQuote happy_var_1,mos happy_var_2,mcs happy_var_4])}}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_391 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_391 = happyMonadReduce 2# 145# happyReduction_391-happyReduction_391 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut290 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsTyVar Promoted happy_var_2)- [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_392 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_392 = happyMonadReduce 5# 145# happyReduction_392-happyReduction_392 (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 happyOut151 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut165 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( addAnnotation (gl happy_var_2) AnnComma- (gl happy_var_3) >>- ams (sLL happy_var_1 happy_var_5 $ HsExplicitListTy NotPromoted- placeHolderKind (happy_var_2 : happy_var_4))- [mos happy_var_1,mcs happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_393 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_393 = happySpecReduce_1 145# happyReduction_393-happyReduction_393 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn161- (sLL happy_var_1 happy_var_1 $ HsTyLit $ HsNumTy (getINTEGERs happy_var_1)- (getINTEGER happy_var_1)- )}--happyReduce_394 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_394 = happySpecReduce_1 145# happyReduction_394-happyReduction_394 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn161- (sLL happy_var_1 happy_var_1 $ HsTyLit $ HsStrTy (getSTRINGs happy_var_1)- (getSTRING happy_var_1)- )}--happyReduce_395 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_395 = happySpecReduce_1 145# happyReduction_395-happyReduction_395 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn161- (sL1 happy_var_1 $ mkAnonWildCardTy- )}--happyReduce_396 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_396 = happySpecReduce_1 146# happyReduction_396-happyReduction_396 happy_x_1- = case happyOut144 happy_x_1 of { happy_var_1 -> - happyIn162- (mkLHsSigType happy_var_1- )}--happyReduce_397 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_397 = happySpecReduce_1 147# happyReduction_397-happyReduction_397 happy_x_1- = case happyOut156 happy_x_1 of { happy_var_1 -> - happyIn163- ([mkLHsSigType happy_var_1]- )}--happyReduce_398 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_398 = happyMonadReduce 3# 147# happyReduction_398-happyReduction_398 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut156 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut163 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)- >> return (mkLHsSigType happy_var_1 : happy_var_3))}}})- ) (\r -> happyReturn (happyIn163 r))--happyReduce_399 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_399 = happySpecReduce_1 148# happyReduction_399-happyReduction_399 happy_x_1- = case happyOut165 happy_x_1 of { happy_var_1 -> - happyIn164- (happy_var_1- )}--happyReduce_400 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_400 = happySpecReduce_0 148# happyReduction_400-happyReduction_400 = happyIn164- ([]- )--happyReduce_401 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_401 = happySpecReduce_1 149# happyReduction_401-happyReduction_401 happy_x_1- = case happyOut151 happy_x_1 of { happy_var_1 -> - happyIn165- ([happy_var_1]- )}--happyReduce_402 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_402 = happyMonadReduce 3# 149# happyReduction_402-happyReduction_402 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut151 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut165 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)- >> return (happy_var_1 : happy_var_3))}}})- ) (\r -> happyReturn (happyIn165 r))--happyReduce_403 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_403 = happyMonadReduce 3# 150# happyReduction_403-happyReduction_403 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut151 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut151 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)- >> return [happy_var_1,happy_var_3])}}})- ) (\r -> happyReturn (happyIn166 r))--happyReduce_404 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_404 = happyMonadReduce 3# 150# happyReduction_404-happyReduction_404 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut151 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut166 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)- >> return (happy_var_1 : happy_var_3))}}})- ) (\r -> happyReturn (happyIn166 r))--happyReduce_405 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_405 = happySpecReduce_2 151# happyReduction_405-happyReduction_405 happy_x_2- happy_x_1- = case happyOut168 happy_x_1 of { happy_var_1 -> - case happyOut167 happy_x_2 of { happy_var_2 -> - happyIn167- (happy_var_1 : happy_var_2- )}}--happyReduce_406 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_406 = happySpecReduce_0 151# happyReduction_406-happyReduction_406 = happyIn167- ([]- )--happyReduce_407 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_407 = happySpecReduce_1 152# happyReduction_407-happyReduction_407 happy_x_1- = case happyOut287 happy_x_1 of { happy_var_1 -> - happyIn168- (sL1 happy_var_1 (UserTyVar happy_var_1)- )}--happyReduce_408 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_408 = happyMonadReduce 5# 152# happyReduction_408-happyReduction_408 (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 happyOut287 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut173 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( ams (sLL happy_var_1 happy_var_5 (KindedTyVar happy_var_2 happy_var_4))- [mop happy_var_1,mu AnnDcolon happy_var_3- ,mcp happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_409 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_409 = happySpecReduce_0 153# happyReduction_409-happyReduction_409 = happyIn169- (noLoc ([],[])- )--happyReduce_410 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_410 = happySpecReduce_2 153# happyReduction_410-happyReduction_410 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut170 happy_x_2 of { happy_var_2 -> - happyIn169- ((sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]- ,reverse (unLoc happy_var_2)))- )}}--happyReduce_411 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_411 = happyMonadReduce 3# 154# happyReduction_411-happyReduction_411 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut170 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut171 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2)- >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn170 r))--happyReduce_412 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_412 = happySpecReduce_1 154# happyReduction_412-happyReduction_412 happy_x_1- = case happyOut171 happy_x_1 of { happy_var_1 -> - happyIn170- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_413 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_413 = happyMonadReduce 3# 155# happyReduction_413-happyReduction_413 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut172 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut172 happy_x_3 of { happy_var_3 -> - ( ams (L (comb3 happy_var_1 happy_var_2 happy_var_3)- (reverse (unLoc happy_var_1), reverse (unLoc happy_var_3)))- [mu AnnRarrow happy_var_2])}}})- ) (\r -> happyReturn (happyIn171 r))--happyReduce_414 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_414 = happySpecReduce_0 156# happyReduction_414-happyReduction_414 = happyIn172- (noLoc []- )--happyReduce_415 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_415 = happySpecReduce_2 156# happyReduction_415-happyReduction_415 happy_x_2- happy_x_1- = case happyOut172 happy_x_1 of { happy_var_1 -> - case happyOut287 happy_x_2 of { happy_var_2 -> - happyIn172- (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)- )}}--happyReduce_416 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_416 = happySpecReduce_1 157# happyReduction_416-happyReduction_416 happy_x_1- = case happyOut151 happy_x_1 of { happy_var_1 -> - happyIn173- (happy_var_1- )}--happyReduce_417 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_417 = happyReduce 4# 158# happyReduction_417-happyReduction_417 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut175 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn174- (L (comb2 happy_var_1 happy_var_3)- ([mj AnnWhere happy_var_1- ,moc happy_var_2- ,mcc happy_var_4]- , unLoc happy_var_3)- ) `HappyStk` happyRest}}}}--happyReduce_418 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_418 = happyReduce 4# 158# happyReduction_418-happyReduction_418 (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 happyOut175 happy_x_3 of { happy_var_3 -> - happyIn174- (L (comb2 happy_var_1 happy_var_3)- ([mj AnnWhere happy_var_1]- , unLoc happy_var_3)- ) `HappyStk` happyRest}}--happyReduce_419 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_419 = happySpecReduce_0 158# happyReduction_419-happyReduction_419 = happyIn174- (noLoc ([],[])- )--happyReduce_420 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_420 = happyMonadReduce 3# 159# happyReduction_420-happyReduction_420 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut176 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut175 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)- >> return (L (comb2 happy_var_1 happy_var_3) (happy_var_1 : unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn175 r))--happyReduce_421 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_421 = happySpecReduce_1 159# happyReduction_421-happyReduction_421 happy_x_1- = case happyOut176 happy_x_1 of { happy_var_1 -> - happyIn175- (L (gl happy_var_1) [happy_var_1]- )}--happyReduce_422 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_422 = happySpecReduce_0 159# happyReduction_422-happyReduction_422 = happyIn175- (noLoc []- )--happyReduce_423 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_423 = happyMonadReduce 3# 160# happyReduction_423-happyReduction_423 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut317 happy_x_1 of { happy_var_1 -> - case happyOut177 happy_x_3 of { happy_var_3 -> - ( return $ addConDoc happy_var_3 happy_var_1)}})- ) (\r -> happyReturn (happyIn176 r))--happyReduce_424 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_424 = happyMonadReduce 1# 160# happyReduction_424-happyReduction_424 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut177 happy_x_1 of { happy_var_1 -> - ( return happy_var_1)})- ) (\r -> happyReturn (happyIn176 r))--happyReduce_425 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_425 = happyMonadReduce 3# 161# happyReduction_425-happyReduction_425 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut266 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut144 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (mkGadtDecl (unLoc happy_var_1) (mkLHsSigType happy_var_3)))- [mu AnnDcolon happy_var_2])}}})- ) (\r -> happyReturn (happyIn177 r))--happyReduce_426 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_426 = happySpecReduce_3 162# happyReduction_426-happyReduction_426 happy_x_3- happy_x_2- happy_x_1- = case happyOut317 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut179 happy_x_3 of { happy_var_3 -> - happyIn178- (L (comb2 happy_var_2 happy_var_3) ([mj AnnEqual happy_var_2]- ,addConDocs (unLoc happy_var_3) happy_var_1)- )}}}--happyReduce_427 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_427 = happyMonadReduce 5# 163# happyReduction_427-happyReduction_427 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut179 happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut316 happy_x_4 of { happy_var_4 -> - case happyOut180 happy_x_5 of { happy_var_5 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_3)- >> return (sLL happy_var_1 happy_var_5 (addConDoc happy_var_5 happy_var_2 : addConDocFirst (unLoc happy_var_1) happy_var_4)))}}}}})- ) (\r -> happyReturn (happyIn179 r))--happyReduce_428 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_428 = happySpecReduce_1 163# happyReduction_428-happyReduction_428 happy_x_1- = case happyOut180 happy_x_1 of { happy_var_1 -> - happyIn179- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_429 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_429 = happyMonadReduce 6# 164# happyReduction_429-happyReduction_429 (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 happyOut317 happy_x_1 of { happy_var_1 -> - case happyOut181 happy_x_2 of { happy_var_2 -> - case happyOut154 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut182 happy_x_5 of { happy_var_5 -> - case happyOut316 happy_x_6 of { happy_var_6 -> - ( ams (let (con,details) = unLoc happy_var_5 in- addConDoc (L (comb4 happy_var_2 happy_var_3 happy_var_4 happy_var_5) (mkConDeclH98 con- (snd $ unLoc happy_var_2) happy_var_3 details))- (happy_var_1 `mplus` happy_var_6))- (mu AnnDarrow happy_var_4:(fst $ unLoc happy_var_2)))}}}}}})- ) (\r -> happyReturn (happyIn180 r))--happyReduce_430 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_430 = happyMonadReduce 4# 164# happyReduction_430-happyReduction_430 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut317 happy_x_1 of { happy_var_1 -> - case happyOut181 happy_x_2 of { happy_var_2 -> - case happyOut182 happy_x_3 of { happy_var_3 -> - case happyOut316 happy_x_4 of { happy_var_4 -> - ( ams ( let (con,details) = unLoc happy_var_3 in- addConDoc (L (comb2 happy_var_2 happy_var_3) (mkConDeclH98 con- (snd $ unLoc happy_var_2) (noLoc []) details))- (happy_var_1 `mplus` happy_var_4))- (fst $ unLoc happy_var_2))}}}})- ) (\r -> happyReturn (happyIn180 r))--happyReduce_431 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_431 = happySpecReduce_3 165# happyReduction_431-happyReduction_431 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut167 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn181- (sLL happy_var_1 happy_var_3 ([mu AnnForall happy_var_1,mj AnnDot happy_var_3], Just happy_var_2)- )}}}--happyReduce_432 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_432 = happySpecReduce_0 165# happyReduction_432-happyReduction_432 = happyIn181- (noLoc ([], Nothing)- )--happyReduce_433 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_433 = happyMonadReduce 1# 166# happyReduction_433-happyReduction_433 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut158 happy_x_1 of { happy_var_1 -> - ( do { c <- splitCon happy_var_1- ; return $ sLL happy_var_1 happy_var_1 c })})- ) (\r -> happyReturn (happyIn182 r))--happyReduce_434 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_434 = happyMonadReduce 3# 166# happyReduction_434-happyReduction_434 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut158 happy_x_1 of { happy_var_1 -> - case happyOut269 happy_x_2 of { happy_var_2 -> - case happyOut158 happy_x_3 of { happy_var_3 -> - ( do { ty <- splitTilde happy_var_1- ; return $ sLL happy_var_1 happy_var_3 (happy_var_2, InfixCon ty happy_var_3) })}}})- ) (\r -> happyReturn (happyIn182 r))--happyReduce_435 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_435 = happySpecReduce_0 167# happyReduction_435-happyReduction_435 = happyIn183- ([]- )--happyReduce_436 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_436 = happySpecReduce_1 167# happyReduction_436-happyReduction_436 happy_x_1- = case happyOut184 happy_x_1 of { happy_var_1 -> - happyIn183- (happy_var_1- )}--happyReduce_437 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_437 = happyMonadReduce 5# 168# happyReduction_437-happyReduction_437 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut185 happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut316 happy_x_4 of { happy_var_4 -> - case happyOut184 happy_x_5 of { happy_var_5 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_3) >>- return ((addFieldDoc happy_var_1 happy_var_4) : addFieldDocs happy_var_5 happy_var_2))}}}}})- ) (\r -> happyReturn (happyIn184 r))--happyReduce_438 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_438 = happySpecReduce_1 168# happyReduction_438-happyReduction_438 happy_x_1- = case happyOut185 happy_x_1 of { happy_var_1 -> - happyIn184- ([happy_var_1]- )}--happyReduce_439 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_439 = happyMonadReduce 5# 169# happyReduction_439-happyReduction_439 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut317 happy_x_1 of { happy_var_1 -> - case happyOut146 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut151 happy_x_4 of { happy_var_4 -> - case happyOut316 happy_x_5 of { happy_var_5 -> - ( ams (L (comb2 happy_var_2 happy_var_4)- (ConDeclField (reverse (map (\ln@(L l n) -> L l $ FieldOcc ln PlaceHolder) (unLoc happy_var_2))) happy_var_4 (happy_var_1 `mplus` happy_var_5)))- [mu AnnDcolon happy_var_3])}}}}})- ) (\r -> happyReturn (happyIn185 r))--happyReduce_440 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_440 = happySpecReduce_0 170# happyReduction_440-happyReduction_440 = happyIn186- (noLoc []- )--happyReduce_441 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_441 = happySpecReduce_1 170# happyReduction_441-happyReduction_441 happy_x_1- = case happyOut187 happy_x_1 of { happy_var_1 -> - happyIn186- (happy_var_1- )}--happyReduce_442 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_442 = happySpecReduce_2 171# happyReduction_442-happyReduction_442 happy_x_2- happy_x_1- = case happyOut187 happy_x_1 of { happy_var_1 -> - case happyOut188 happy_x_2 of { happy_var_2 -> - happyIn187- (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1- )}}--happyReduce_443 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_443 = happySpecReduce_1 171# happyReduction_443-happyReduction_443 happy_x_1- = case happyOut188 happy_x_1 of { happy_var_1 -> - happyIn187- (sLL happy_var_1 happy_var_1 [happy_var_1]- )}--happyReduce_444 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_444 = happyMonadReduce 3# 172# happyReduction_444-happyReduction_444 (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 happyOut82 happy_x_2 of { happy_var_2 -> - case happyOut277 happy_x_3 of { happy_var_3 -> - ( let { full_loc = comb2 happy_var_1 happy_var_3 }- in ams (L full_loc $ HsDerivingClause happy_var_2 $ L full_loc- [mkLHsSigType happy_var_3])- [mj AnnDeriving happy_var_1])}}})- ) (\r -> happyReturn (happyIn188 r))--happyReduce_445 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_445 = happyMonadReduce 4# 172# happyReduction_445-happyReduction_445 (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 happyOut82 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( let { full_loc = comb2 happy_var_1 happy_var_4 }- in ams (L full_loc $ HsDerivingClause happy_var_2 $ L full_loc [])- [mj AnnDeriving happy_var_1,mop happy_var_3,mcp happy_var_4])}}}})- ) (\r -> happyReturn (happyIn188 r))--happyReduce_446 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_446 = happyMonadReduce 5# 172# happyReduction_446-happyReduction_446 (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 happyOut82 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut163 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( let { full_loc = comb2 happy_var_1 happy_var_5 }- in ams (L full_loc $ HsDerivingClause happy_var_2 $ L full_loc happy_var_4)- [mj AnnDeriving happy_var_1,mop happy_var_3,mcp happy_var_5])}}}}})- ) (\r -> happyReturn (happyIn188 r))--happyReduce_447 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_447 = happySpecReduce_1 173# happyReduction_447-happyReduction_447 happy_x_1- = case happyOut190 happy_x_1 of { happy_var_1 -> - happyIn189- (sL1 happy_var_1 (DocD (unLoc happy_var_1))- )}--happyReduce_448 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_448 = happySpecReduce_1 174# happyReduction_448-happyReduction_448 happy_x_1- = case happyOut311 happy_x_1 of { happy_var_1 -> - happyIn190- (sL1 happy_var_1 (DocCommentNext (unLoc happy_var_1))- )}--happyReduce_449 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_449 = happySpecReduce_1 174# happyReduction_449-happyReduction_449 happy_x_1- = case happyOut312 happy_x_1 of { happy_var_1 -> - happyIn190- (sL1 happy_var_1 (DocCommentPrev (unLoc happy_var_1))- )}--happyReduce_450 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_450 = happySpecReduce_1 174# happyReduction_450-happyReduction_450 happy_x_1- = case happyOut313 happy_x_1 of { happy_var_1 -> - happyIn190- (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocCommentNamed n doc)- )}--happyReduce_451 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_451 = happySpecReduce_1 174# happyReduction_451-happyReduction_451 happy_x_1- = case happyOut314 happy_x_1 of { happy_var_1 -> - happyIn190- (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocGroup n doc)- )}--happyReduce_452 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_452 = happySpecReduce_1 175# happyReduction_452-happyReduction_452 happy_x_1- = case happyOut196 happy_x_1 of { happy_var_1 -> - happyIn191- (happy_var_1- )}--happyReduce_453 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_453 = happyMonadReduce 3# 175# happyReduction_453-happyReduction_453 (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 happyOut209 happy_x_2 of { happy_var_2 -> - case happyOut193 happy_x_3 of { happy_var_3 -> - ( do { let { e = sLL happy_var_1 happy_var_2 (SectionR (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)- -- Turn it all into an expression so that- -- checkPattern can check that bangs are enabled- ; l = comb2 happy_var_1 happy_var_3 };- (ann, r) <- checkValDef empty SrcStrict e Nothing happy_var_3 ;- -- Depending upon what the pattern looks like we might get either- -- a FunBind or PatBind back from checkValDef. See Note- -- [Varieties of binding pattern matches]- case r of {- (FunBind n _ _ _ _) ->- ams (L l ()) [mj AnnFunId n] >> return () ;- (PatBind (L lh _lhs) _rhs _ _ _) ->- ams (L lh ()) [] >> return () } ;-- _ <- ams (L l ()) (ann ++ fst (unLoc happy_var_3) ++ [mj AnnBang happy_var_1]) ;- return $! (sL l $ ValD r) })}}})- ) (\r -> happyReturn (happyIn191 r))--happyReduce_454 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_454 = happyMonadReduce 3# 175# happyReduction_454-happyReduction_454 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut202 happy_x_1 of { happy_var_1 -> - case happyOut141 happy_x_2 of { happy_var_2 -> - case happyOut193 happy_x_3 of { happy_var_3 -> - ( do { (ann,r) <- checkValDef empty NoSrcStrict happy_var_1 (snd happy_var_2) happy_var_3;- let { l = comb2 happy_var_1 happy_var_3 };- -- Depending upon what the pattern looks like we might get either- -- a FunBind or PatBind back from checkValDef. See Note- -- [Varieties of binding pattern matches]- case r of {- (FunBind n _ _ _ _) ->- ams (L l ()) (mj AnnFunId n:(fst happy_var_2)) >> return () ;- (PatBind (L lh _lhs) _rhs _ _ _) ->- ams (L lh ()) (fst happy_var_2) >> return () } ;- _ <- ams (L l ()) (ann ++ (fst $ unLoc happy_var_3));- return $! (sL l $ ValD r) })}}})- ) (\r -> happyReturn (happyIn191 r))--happyReduce_455 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_455 = happySpecReduce_1 175# happyReduction_455-happyReduction_455 happy_x_1- = case happyOut105 happy_x_1 of { happy_var_1 -> - happyIn191- (happy_var_1- )}--happyReduce_456 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_456 = happySpecReduce_1 175# happyReduction_456-happyReduction_456 happy_x_1- = case happyOut189 happy_x_1 of { happy_var_1 -> - happyIn191- (happy_var_1- )}--happyReduce_457 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_457 = happySpecReduce_1 176# happyReduction_457-happyReduction_457 happy_x_1- = case happyOut191 happy_x_1 of { happy_var_1 -> - happyIn192- (happy_var_1- )}--happyReduce_458 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_458 = happySpecReduce_1 176# happyReduction_458-happyReduction_458 happy_x_1- = case happyOut212 happy_x_1 of { happy_var_1 -> - happyIn192- (sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1- )}--happyReduce_459 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_459 = happySpecReduce_3 177# happyReduction_459-happyReduction_459 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - case happyOut122 happy_x_3 of { happy_var_3 -> - happyIn193- (sL (comb3 happy_var_1 happy_var_2 happy_var_3)- ((mj AnnEqual happy_var_1 : (fst $ unLoc happy_var_3))- ,GRHSs (unguardedRHS (comb3 happy_var_1 happy_var_2 happy_var_3) happy_var_2)- (snd $ unLoc happy_var_3))- )}}}--happyReduce_460 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_460 = happySpecReduce_2 177# happyReduction_460-happyReduction_460 happy_x_2- happy_x_1- = case happyOut194 happy_x_1 of { happy_var_1 -> - case happyOut122 happy_x_2 of { happy_var_2 -> - happyIn193- (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_2- ,GRHSs (reverse (unLoc happy_var_1))- (snd $ unLoc happy_var_2))- )}}--happyReduce_461 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_461 = happySpecReduce_2 178# happyReduction_461-happyReduction_461 happy_x_2- happy_x_1- = case happyOut194 happy_x_1 of { happy_var_1 -> - case happyOut195 happy_x_2 of { happy_var_2 -> - happyIn194- (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)- )}}--happyReduce_462 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_462 = happySpecReduce_1 178# happyReduction_462-happyReduction_462 happy_x_1- = case happyOut195 happy_x_1 of { happy_var_1 -> - happyIn194- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_463 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_463 = happyMonadReduce 4# 179# happyReduction_463-happyReduction_463 (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 happyOut228 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - ( ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS (unLoc happy_var_2) happy_var_4)- [mj AnnVbar happy_var_1,mj AnnEqual happy_var_3])}}}})- ) (\r -> happyReturn (happyIn195 r))--happyReduce_464 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_464 = happyMonadReduce 3# 180# happyReduction_464-happyReduction_464 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut202 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut145 happy_x_3 of { happy_var_3 -> - ( do v <- checkValSigLhs happy_var_1- ; _ <- ams (sLL happy_var_1 happy_var_3 ()) [mu AnnDcolon happy_var_2]- ; return (sLL happy_var_1 happy_var_3 $ SigD $- TypeSig [v] (mkLHsSigWcType happy_var_3)))}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_465 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_465 = happyMonadReduce 5# 180# happyReduction_465-happyReduction_465 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut290 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut146 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut145 happy_x_5 of { happy_var_5 -> - ( do { let sig = TypeSig (happy_var_1 : reverse (unLoc happy_var_3))- (mkLHsSigWcType happy_var_5)- ; addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)- ; ams ( sLL happy_var_1 happy_var_5 $ SigD sig )- [mu AnnDcolon happy_var_4] })}}}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_466 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_466 = happyMonadReduce 3# 180# happyReduction_466-happyReduction_466 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut73 happy_x_1 of { happy_var_1 -> - case happyOut72 happy_x_2 of { happy_var_2 -> - case happyOut74 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ SigD- (FixSig (FixitySig (fromOL $ unLoc happy_var_3)- (Fixity (fst $ unLoc happy_var_2) (snd $ unLoc happy_var_2) (unLoc happy_var_1)))))- [mj AnnInfix happy_var_1,mj AnnVal happy_var_2])}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_467 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_467 = happySpecReduce_1 180# happyReduction_467-happyReduction_467 happy_x_1- = case happyOut110 happy_x_1 of { happy_var_1 -> - happyIn196- (sLL happy_var_1 happy_var_1 . SigD . unLoc $ happy_var_1- )}--happyReduce_468 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_468 = happyMonadReduce 4# 180# happyReduction_468-happyReduction_468 (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 happyOut266 happy_x_2 of { happy_var_2 -> - case happyOut143 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( let (dcolon, tc) = happy_var_3- in ams- (sLL happy_var_1 happy_var_4- (SigD (CompleteMatchSig (getCOMPLETE_PRAGs happy_var_1) happy_var_2 tc)))- ([ mo happy_var_1 ] ++ dcolon ++ [mc happy_var_4]))}}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_469 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_469 = happyMonadReduce 4# 180# happyReduction_469-happyReduction_469 (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 happyOut197 happy_x_2 of { happy_var_2 -> - case happyOut291 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams ((sLL happy_var_1 happy_var_4 $ SigD (InlineSig happy_var_3- (mkInlinePragma (getINLINE_PRAGs happy_var_1) (getINLINE happy_var_1)- (snd happy_var_2)))))- ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_4]))}}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_470 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_470 = happyMonadReduce 3# 180# happyReduction_470-happyReduction_470 (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 happyOut291 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (SigD (SCCFunSig (getSCC_PRAGs happy_var_1) happy_var_2 Nothing)))- [mo happy_var_1, mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_471 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_471 = happyMonadReduce 4# 180# happyReduction_471-happyReduction_471 (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 happyOut291 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( do { scc <- getSCC happy_var_3- ; let str_lit = StringLiteral (getSTRINGs happy_var_3) scc- ; ams (sLL happy_var_1 happy_var_4 (SigD (SCCFunSig (getSCC_PRAGs happy_var_1) happy_var_2 (Just ( sL1 happy_var_3 str_lit)))))- [mo happy_var_1, mc happy_var_4] })}}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_472 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_472 = happyMonadReduce 6# 180# happyReduction_472-happyReduction_472 (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 happyOut197 happy_x_2 of { happy_var_2 -> - case happyOut291 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut147 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( ams (- let inl_prag = mkInlinePragma (getSPEC_PRAGs happy_var_1)- (EmptyInlineSpec, FunLike) (snd happy_var_2)- in sLL happy_var_1 happy_var_6 $ SigD (SpecSig happy_var_3 (fromOL happy_var_5) inl_prag))- (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_473 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_473 = happyMonadReduce 6# 180# happyReduction_473-happyReduction_473 (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 happyOut197 happy_x_2 of { happy_var_2 -> - case happyOut291 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut147 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( ams (sLL happy_var_1 happy_var_6 $ SigD (SpecSig happy_var_3 (fromOL happy_var_5)- (mkInlinePragma (getSPEC_INLINE_PRAGs happy_var_1)- (getSPEC_INLINE happy_var_1) (snd happy_var_2))))- (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_474 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_474 = happyMonadReduce 4# 180# happyReduction_474-happyReduction_474 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut162 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4- $ SigD (SpecInstSig (getSPEC_PRAGs happy_var_1) happy_var_3))- [mo happy_var_1,mj AnnInstance happy_var_2,mc happy_var_4])}}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_475 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_475 = happyMonadReduce 3# 180# happyReduction_475-happyReduction_475 (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 happyOut255 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ SigD (MinimalSig (getMINIMAL_PRAGs happy_var_1) happy_var_2))- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_476 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_476 = happySpecReduce_0 181# happyReduction_476-happyReduction_476 = happyIn197- (([],Nothing)- )--happyReduce_477 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_477 = happySpecReduce_1 181# happyReduction_477-happyReduction_477 happy_x_1- = case happyOut198 happy_x_1 of { happy_var_1 -> - happyIn197- ((fst happy_var_1,Just (snd happy_var_1))- )}--happyReduce_478 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_478 = happySpecReduce_3 182# happyReduction_478-happyReduction_478 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn198- (([mj AnnOpenS happy_var_1,mj AnnVal happy_var_2,mj AnnCloseS happy_var_3]- ,ActiveAfter (getINTEGERs happy_var_2) (fromInteger (getINTEGER happy_var_2)))- )}}}--happyReduce_479 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_479 = happyReduce 4# 182# 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 { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn198- (([mj AnnOpenS happy_var_1,mj AnnTilde happy_var_2,mj AnnVal happy_var_3- ,mj AnnCloseS happy_var_4]- ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (getINTEGER happy_var_3)))- ) `HappyStk` happyRest}}}}--happyReduce_480 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_480 = happySpecReduce_1 183# happyReduction_480-happyReduction_480 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn199- (let { loc = getLoc happy_var_1- ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc happy_var_1- ; quoterId = mkUnqual varName quoter }- in sL1 happy_var_1 (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote)- )}--happyReduce_481 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_481 = happySpecReduce_1 183# happyReduction_481-happyReduction_481 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn199- (let { loc = getLoc happy_var_1- ; ITqQuasiQuote (qual, quoter, quote, quoteSpan) = unLoc happy_var_1- ; quoterId = mkQual varName (qual, quoter) }- in sL (getLoc happy_var_1) (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote)- )}--happyReduce_482 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_482 = happyMonadReduce 3# 184# happyReduction_482-happyReduction_482 (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 { happy_var_2 -> - case happyOut144 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ ExprWithTySig happy_var_1 (mkLHsSigWcType happy_var_3))- [mu AnnDcolon happy_var_2])}}})- ) (\r -> happyReturn (happyIn200 r))--happyReduce_483 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_483 = happyMonadReduce 3# 184# happyReduction_483-happyReduction_483 (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 { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_1 happy_var_3 placeHolderType- HsFirstOrderApp True)- [mu Annlarrowtail happy_var_2])}}})- ) (\r -> happyReturn (happyIn200 r))--happyReduce_484 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_484 = happyMonadReduce 3# 184# happyReduction_484-happyReduction_484 (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 { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_3 happy_var_1 placeHolderType- HsFirstOrderApp False)- [mu Annrarrowtail happy_var_2])}}})- ) (\r -> happyReturn (happyIn200 r))--happyReduce_485 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_485 = happyMonadReduce 3# 184# happyReduction_485-happyReduction_485 (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 { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_1 happy_var_3 placeHolderType- HsHigherOrderApp True)- [mu AnnLarrowtail happy_var_2])}}})- ) (\r -> happyReturn (happyIn200 r))--happyReduce_486 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_486 = happyMonadReduce 3# 184# happyReduction_486-happyReduction_486 (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 { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_3 happy_var_1 placeHolderType- HsHigherOrderApp False)- [mu AnnRarrowtail happy_var_2])}}})- ) (\r -> happyReturn (happyIn200 r))--happyReduce_487 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_487 = happySpecReduce_1 184# happyReduction_487-happyReduction_487 happy_x_1- = case happyOut201 happy_x_1 of { happy_var_1 -> - happyIn200- (happy_var_1- )}--happyReduce_488 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_488 = happySpecReduce_1 185# happyReduction_488-happyReduction_488 happy_x_1- = case happyOut204 happy_x_1 of { happy_var_1 -> - happyIn201- (happy_var_1- )}--happyReduce_489 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_489 = happyMonadReduce 3# 185# happyReduction_489-happyReduction_489 (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 happyOut283 happy_x_2 of { happy_var_2 -> - case happyOut204 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (OpApp happy_var_1 happy_var_2 placeHolderFixity happy_var_3))- [mj AnnVal happy_var_2])}}})- ) (\r -> happyReturn (happyIn201 r))--happyReduce_490 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_490 = happySpecReduce_1 186# happyReduction_490-happyReduction_490 happy_x_1- = case happyOut203 happy_x_1 of { happy_var_1 -> - happyIn202- (happy_var_1- )}--happyReduce_491 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_491 = happyMonadReduce 3# 186# happyReduction_491-happyReduction_491 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut202 happy_x_1 of { happy_var_1 -> - case happyOut283 happy_x_2 of { happy_var_2 -> - case happyOut203 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (OpApp happy_var_1 happy_var_2 placeHolderFixity happy_var_3))- [mj AnnVal happy_var_2])}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_492 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_492 = happyMonadReduce 6# 187# happyReduction_492-happyReduction_492 (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 happyOut241 happy_x_2 of { happy_var_2 -> - case happyOut242 happy_x_3 of { happy_var_3 -> - case happyOut142 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut200 happy_x_6 of { happy_var_6 -> - ( ams (sLL happy_var_1 happy_var_6 $ HsLam (mkMatchGroup FromSource- [sLL happy_var_1 happy_var_6 $ Match { m_ctxt = LambdaExpr- , m_pats = happy_var_2:happy_var_3- , m_type = snd happy_var_4- , m_grhss = unguardedGRHSs happy_var_6 }]))- (mj AnnLam happy_var_1:mu AnnRarrow happy_var_5:(fst happy_var_4)))}}}}}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_493 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_493 = happyMonadReduce 4# 187# happyReduction_493-happyReduction_493 (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 happyOut121 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $ HsLet (snd $ unLoc happy_var_2) happy_var_4)- (mj AnnLet happy_var_1:mj AnnIn happy_var_3- :(fst $ unLoc happy_var_2)))}}}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_494 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_494 = happyMonadReduce 3# 187# happyReduction_494-happyReduction_494 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut230 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsLamCase- (mkMatchGroup FromSource (snd $ unLoc happy_var_3)))- (mj AnnLam happy_var_1:mj AnnCase happy_var_2:(fst $ unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_495 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_495 = happyMonadReduce 8# 187# happyReduction_495-happyReduction_495 (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 { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - case happyOut205 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut200 happy_x_5 of { happy_var_5 -> - case happyOut205 happy_x_6 of { happy_var_6 -> - case happyOutTok happy_x_7 of { happy_var_7 -> - case happyOut200 happy_x_8 of { happy_var_8 -> - ( checkDoAndIfThenElse happy_var_2 (snd happy_var_3) happy_var_5 (snd happy_var_6) happy_var_8 >>- ams (sLL happy_var_1 happy_var_8 $ mkHsIf happy_var_2 happy_var_5 happy_var_8)- (mj AnnIf happy_var_1:mj AnnThen happy_var_4- :mj AnnElse happy_var_7- :(map (\l -> mj AnnSemi l) (fst happy_var_3))- ++(map (\l -> mj AnnSemi l) (fst happy_var_6))))}}}}}}}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_496 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_496 = happyMonadReduce 2# 187# happyReduction_496-happyReduction_496 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut237 happy_x_2 of { happy_var_2 -> - ( hintMultiWayIf (getLoc happy_var_1) >>- ams (sLL happy_var_1 happy_var_2 $ HsMultiIf- placeHolderType- (reverse $ snd $ unLoc happy_var_2))- (mj AnnIf happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_497 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_497 = happyMonadReduce 4# 187# 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 { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut230 happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $ HsCase happy_var_2 (mkMatchGroup- FromSource (snd $ unLoc happy_var_4)))- (mj AnnCase happy_var_1:mj AnnOf happy_var_3- :(fst $ unLoc happy_var_4)))}}}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_498 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_498 = happyMonadReduce 2# 187# happyReduction_498-happyReduction_498 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut208 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ NegApp happy_var_2 noSyntaxExpr)- [mj AnnMinus happy_var_1])}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_499 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_499 = happyMonadReduce 2# 187# happyReduction_499-happyReduction_499 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut243 happy_x_2 of { happy_var_2 -> - ( ams (L (comb2 happy_var_1 happy_var_2)- (mkHsDo DoExpr (snd $ unLoc happy_var_2)))- (mj AnnDo happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_500 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_500 = happyMonadReduce 2# 187# happyReduction_500-happyReduction_500 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut243 happy_x_2 of { happy_var_2 -> - ( ams (L (comb2 happy_var_1 happy_var_2)- (mkHsDo MDoExpr (snd $ unLoc happy_var_2)))- (mj AnnMdo happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_501 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_501 = happyMonadReduce 2# 187# happyReduction_501-happyReduction_501 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsTickPragma (snd $ fst $ fst $ unLoc happy_var_1)- (snd $ fst $ unLoc happy_var_1) (snd $ unLoc happy_var_1) happy_var_2)- (fst $ fst $ fst $ unLoc happy_var_1))}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_502 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_502 = happyMonadReduce 4# 187# happyReduction_502-happyReduction_502 (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 happyOut209 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - ( checkPattern empty happy_var_2 >>= \ p ->- checkCommand happy_var_4 >>= \ cmd ->- ams (sLL happy_var_1 happy_var_4 $ HsProc p (sLL happy_var_1 happy_var_4 $ HsCmdTop cmd placeHolderType- placeHolderType []))- -- TODO: is LL right here?- [mj AnnProc happy_var_1,mu AnnRarrow happy_var_3])}}}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_503 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_503 = happyMonadReduce 4# 187# happyReduction_503-happyReduction_503 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $ HsCoreAnn (getCORE_PRAGs happy_var_1) (getStringLiteral happy_var_2) happy_var_4)- [mo happy_var_1,mj AnnVal happy_var_2- ,mc happy_var_3])}}}})- ) (\r -> happyReturn (happyIn203 r))--happyReduce_504 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_504 = happySpecReduce_1 187# happyReduction_504-happyReduction_504 happy_x_1- = case happyOut208 happy_x_1 of { happy_var_1 -> - happyIn203- (happy_var_1- )}--happyReduce_505 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_505 = happySpecReduce_1 188# happyReduction_505-happyReduction_505 happy_x_1- = case happyOut203 happy_x_1 of { happy_var_1 -> - happyIn204- (happy_var_1- )}--happyReduce_506 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_506 = happyMonadReduce 2# 188# happyReduction_506-happyReduction_506 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut206 happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsSCC (snd $ fst $ unLoc happy_var_1) (snd $ unLoc happy_var_1) happy_var_2)- (fst $ fst $ unLoc happy_var_1))}})- ) (\r -> happyReturn (happyIn204 r))--happyReduce_507 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_507 = happySpecReduce_1 189# happyReduction_507-happyReduction_507 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn205- (([happy_var_1],True)- )}--happyReduce_508 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_508 = happySpecReduce_0 189# happyReduction_508-happyReduction_508 = happyIn205- (([],False)- )--happyReduce_509 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_509 = happyMonadReduce 3# 190# happyReduction_509-happyReduction_509 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do scc <- getSCC happy_var_2- ; return $ sLL happy_var_1 happy_var_3- (([mo happy_var_1,mj AnnValStr happy_var_2- ,mc happy_var_3],getSCC_PRAGs happy_var_1),(StringLiteral (getSTRINGs happy_var_2) scc)))}}})- ) (\r -> happyReturn (happyIn206 r))--happyReduce_510 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_510 = happySpecReduce_3 190# happyReduction_510-happyReduction_510 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn206- (sLL happy_var_1 happy_var_3 (([mo happy_var_1,mj AnnVal happy_var_2- ,mc happy_var_3],getSCC_PRAGs happy_var_1)- ,(StringLiteral NoSourceText (getVARID happy_var_2)))- )}}}--happyReduce_511 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_511 = happyReduce 10# 191# happyReduction_511-happyReduction_511 (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 { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { happy_var_6 -> - case happyOutTok happy_x_7 of { happy_var_7 -> - case happyOutTok happy_x_8 of { happy_var_8 -> - case happyOutTok happy_x_9 of { happy_var_9 -> - case happyOutTok happy_x_10 of { happy_var_10 -> - happyIn207- (sLL happy_var_1 happy_var_10 $ ((([mo happy_var_1,mj AnnVal happy_var_2- ,mj AnnVal happy_var_3,mj AnnColon happy_var_4- ,mj AnnVal happy_var_5,mj AnnMinus happy_var_6- ,mj AnnVal happy_var_7,mj AnnColon happy_var_8- ,mj AnnVal happy_var_9,mc happy_var_10],- getGENERATED_PRAGs happy_var_1)- ,((getStringLiteral happy_var_2)- ,( fromInteger $ getINTEGER happy_var_3- , fromInteger $ getINTEGER happy_var_5- )- ,( fromInteger $ getINTEGER happy_var_7- , fromInteger $ getINTEGER happy_var_9- )- ))- , (( getINTEGERs happy_var_3- , getINTEGERs happy_var_5- )- ,( getINTEGERs happy_var_7- , getINTEGERs happy_var_9- )))- ) `HappyStk` happyRest}}}}}}}}}}--happyReduce_512 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_512 = happySpecReduce_2 192# happyReduction_512-happyReduction_512 happy_x_2- happy_x_1- = case happyOut208 happy_x_1 of { happy_var_1 -> - case happyOut209 happy_x_2 of { happy_var_2 -> - happyIn208- (sLL happy_var_1 happy_var_2 $ HsApp happy_var_1 happy_var_2- )}}--happyReduce_513 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_513 = happyMonadReduce 3# 192# happyReduction_513-happyReduction_513 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut208 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut161 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsAppType happy_var_1 (mkHsWildCardBndrs happy_var_3))- [mj AnnAt happy_var_2])}}})- ) (\r -> happyReturn (happyIn208 r))--happyReduce_514 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_514 = happyMonadReduce 2# 192# happyReduction_514-happyReduction_514 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut209 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsStatic placeHolderNames happy_var_2)- [mj AnnStatic happy_var_1])}})- ) (\r -> happyReturn (happyIn208 r))--happyReduce_515 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_515 = happySpecReduce_1 192# happyReduction_515-happyReduction_515 happy_x_1- = case happyOut209 happy_x_1 of { happy_var_1 -> - happyIn208- (happy_var_1- )}--happyReduce_516 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_516 = happyMonadReduce 3# 193# happyReduction_516-happyReduction_516 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut291 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut209 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ EAsPat happy_var_1 happy_var_3) [mj AnnAt happy_var_2])}}})- ) (\r -> happyReturn (happyIn209 r))--happyReduce_517 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_517 = happyMonadReduce 2# 193# happyReduction_517-happyReduction_517 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut209 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ ELazyPat happy_var_2) [mj AnnTilde happy_var_1])}})- ) (\r -> happyReturn (happyIn209 r))--happyReduce_518 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_518 = happySpecReduce_1 193# happyReduction_518-happyReduction_518 happy_x_1- = case happyOut210 happy_x_1 of { happy_var_1 -> - happyIn209- (happy_var_1- )}--happyReduce_519 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_519 = happyMonadReduce 4# 194# happyReduction_519-happyReduction_519 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut210 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut248 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( do { r <- mkRecConstrOrUpdate happy_var_1 (comb2 happy_var_2 happy_var_4)- (snd happy_var_3)- ; _ <- ams (sLL happy_var_1 happy_var_4 ()) (moc happy_var_2:mcc happy_var_4:(fst happy_var_3))- ; checkRecordSyntax (sLL happy_var_1 happy_var_4 r) })}}}})- ) (\r -> happyReturn (happyIn210 r))--happyReduce_520 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_520 = happySpecReduce_1 194# happyReduction_520-happyReduction_520 happy_x_1- = case happyOut211 happy_x_1 of { happy_var_1 -> - happyIn210- (happy_var_1- )}--happyReduce_521 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_521 = happySpecReduce_1 195# happyReduction_521-happyReduction_521 happy_x_1- = case happyOut291 happy_x_1 of { happy_var_1 -> - happyIn211- (sL1 happy_var_1 (HsVar $! happy_var_1)- )}--happyReduce_522 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_522 = happySpecReduce_1 195# happyReduction_522-happyReduction_522 happy_x_1- = case happyOut263 happy_x_1 of { happy_var_1 -> - happyIn211- (sL1 happy_var_1 (HsVar $! happy_var_1)- )}--happyReduce_523 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_523 = happySpecReduce_1 195# happyReduction_523-happyReduction_523 happy_x_1- = case happyOut253 happy_x_1 of { happy_var_1 -> - happyIn211- (sL1 happy_var_1 (HsIPVar $! unLoc happy_var_1)- )}--happyReduce_524 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_524 = happySpecReduce_1 195# happyReduction_524-happyReduction_524 happy_x_1- = case happyOut254 happy_x_1 of { happy_var_1 -> - happyIn211- (sL1 happy_var_1 (HsOverLabel Nothing $! unLoc happy_var_1)- )}--happyReduce_525 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_525 = happySpecReduce_1 195# happyReduction_525-happyReduction_525 happy_x_1- = case happyOut305 happy_x_1 of { happy_var_1 -> - happyIn211- (sL1 happy_var_1 (HsLit $! unLoc happy_var_1)- )}--happyReduce_526 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_526 = happySpecReduce_1 195# happyReduction_526-happyReduction_526 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn211- (sL (getLoc happy_var_1) (HsOverLit $! mkHsIntegral (getINTEGERs happy_var_1)- (getINTEGER happy_var_1) placeHolderType)- )}--happyReduce_527 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_527 = happySpecReduce_1 195# happyReduction_527-happyReduction_527 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn211- (sL (getLoc happy_var_1) (HsOverLit $! mkHsFractional- (getRATIONAL happy_var_1) placeHolderType)- )}--happyReduce_528 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_528 = happyMonadReduce 3# 195# happyReduction_528-happyReduction_528 (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 happyOut217 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (HsPar happy_var_2)) [mop happy_var_1,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_529 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_529 = happyMonadReduce 3# 195# happyReduction_529-happyReduction_529 (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 happyOut218 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do { e <- mkSumOrTuple Boxed (comb2 happy_var_1 happy_var_3) (snd happy_var_2)- ; ams (sLL happy_var_1 happy_var_3 e) ((mop happy_var_1:fst happy_var_2) ++ [mcp happy_var_3]) })}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_530 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_530 = happyMonadReduce 3# 195# happyReduction_530-happyReduction_530 (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 happyOut217 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (ExplicitTuple [L (gl happy_var_2)- (Present happy_var_2)] Unboxed))- [mo happy_var_1,mc happy_var_3])}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_531 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_531 = happyMonadReduce 3# 195# happyReduction_531-happyReduction_531 (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 happyOut218 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do { e <- mkSumOrTuple Unboxed (comb2 happy_var_1 happy_var_3) (snd happy_var_2)- ; ams (sLL happy_var_1 happy_var_3 e) ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_3]) })}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_532 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_532 = happyMonadReduce 3# 195# happyReduction_532-happyReduction_532 (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 happyOut221 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (snd happy_var_2)) (mos happy_var_1:mcs happy_var_3:(fst happy_var_2)))}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_533 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_533 = happyMonadReduce 3# 195# happyReduction_533-happyReduction_533 (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 happyOut227 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (snd happy_var_2)) (mo happy_var_1:mc happy_var_3:(fst happy_var_2)))}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_534 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_534 = happySpecReduce_1 195# happyReduction_534-happyReduction_534 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn211- (sL1 happy_var_1 EWildPat- )}--happyReduce_535 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_535 = happySpecReduce_1 195# happyReduction_535-happyReduction_535 happy_x_1- = case happyOut212 happy_x_1 of { happy_var_1 -> - happyIn211- (happy_var_1- )}--happyReduce_536 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_536 = happyMonadReduce 2# 195# happyReduction_536-happyReduction_536 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut291 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr True (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_537 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_537 = happyMonadReduce 2# 195# happyReduction_537-happyReduction_537 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut263 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr True (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_538 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_538 = happyMonadReduce 2# 195# happyReduction_538-happyReduction_538 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut287 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_539 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_539 = happyMonadReduce 2# 195# happyReduction_539-happyReduction_539 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut271 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_540 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_540 = happyMonadReduce 3# 195# happyReduction_540-happyReduction_540 (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 happyOut200 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (ExpBr happy_var_2))- (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1, mu AnnCloseQ happy_var_3]- else [mu AnnOpenEQ happy_var_1,mu AnnCloseQ happy_var_3]))}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_541 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_541 = happyMonadReduce 3# 195# happyReduction_541-happyReduction_541 (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 happyOut200 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (TExpBr happy_var_2))- (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1,mc happy_var_3] else [mo happy_var_1,mc happy_var_3]))}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_542 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_542 = happyMonadReduce 3# 195# happyReduction_542-happyReduction_542 (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 happyOut151 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (TypBr happy_var_2)) [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_543 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_543 = happyMonadReduce 3# 195# happyReduction_543-happyReduction_543 (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 happyOut201 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( checkPattern empty happy_var_2 >>= \p ->- ams (sLL happy_var_1 happy_var_3 $ HsBracket (PatBr p))- [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_544 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_544 = happyMonadReduce 3# 195# happyReduction_544-happyReduction_544 (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 happyOut215 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (DecBrL (snd happy_var_2)))- (mo happy_var_1:mu AnnCloseQ happy_var_3:fst happy_var_2))}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_545 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_545 = happySpecReduce_1 195# happyReduction_545-happyReduction_545 happy_x_1- = case happyOut199 happy_x_1 of { happy_var_1 -> - happyIn211- (sL1 happy_var_1 (HsSpliceE (unLoc happy_var_1))- )}--happyReduce_546 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_546 = happyMonadReduce 4# 195# happyReduction_546-happyReduction_546 (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 happyOut211 happy_x_2 of { happy_var_2 -> - case happyOut213 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( ams (sLL happy_var_1 happy_var_4 $ HsArrForm happy_var_2- Nothing (reverse happy_var_3))- [mu AnnOpenB happy_var_1,mu AnnCloseB happy_var_4])}}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_547 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_547 = happyMonadReduce 1# 196# happyReduction_547-happyReduction_547 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( ams (sL1 happy_var_1 $ mkHsSpliceE HasDollar- (sL1 happy_var_1 $ HsVar (sL1 happy_var_1 (mkUnqual varName- (getTH_ID_SPLICE happy_var_1)))))- [mj AnnThIdSplice happy_var_1])})- ) (\r -> happyReturn (happyIn212 r))--happyReduce_548 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_548 = happyMonadReduce 3# 196# happyReduction_548-happyReduction_548 (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 happyOut200 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ mkHsSpliceE HasParens happy_var_2)- [mj AnnOpenPE happy_var_1,mj AnnCloseP happy_var_3])}}})- ) (\r -> happyReturn (happyIn212 r))--happyReduce_549 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_549 = happyMonadReduce 1# 196# happyReduction_549-happyReduction_549 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( ams (sL1 happy_var_1 $ mkHsSpliceTE HasDollar- (sL1 happy_var_1 $ HsVar (sL1 happy_var_1 (mkUnqual varName- (getTH_ID_TY_SPLICE happy_var_1)))))- [mj AnnThIdTySplice happy_var_1])})- ) (\r -> happyReturn (happyIn212 r))--happyReduce_550 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_550 = happyMonadReduce 3# 196# happyReduction_550-happyReduction_550 (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 happyOut200 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ mkHsSpliceTE HasParens happy_var_2)- [mj AnnOpenPTE happy_var_1,mj AnnCloseP happy_var_3])}}})- ) (\r -> happyReturn (happyIn212 r))--happyReduce_551 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_551 = happySpecReduce_2 197# happyReduction_551-happyReduction_551 happy_x_2- happy_x_1- = case happyOut213 happy_x_1 of { happy_var_1 -> - case happyOut214 happy_x_2 of { happy_var_2 -> - happyIn213- (happy_var_2 : happy_var_1- )}}--happyReduce_552 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_552 = happySpecReduce_0 197# happyReduction_552-happyReduction_552 = happyIn213- ([]- )--happyReduce_553 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_553 = happyMonadReduce 1# 198# happyReduction_553-happyReduction_553 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut211 happy_x_1 of { happy_var_1 -> - ( checkCommand happy_var_1 >>= \ cmd ->- return (sL1 happy_var_1 $ HsCmdTop cmd- placeHolderType placeHolderType []))})- ) (\r -> happyReturn (happyIn214 r))--happyReduce_554 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_554 = happySpecReduce_3 199# happyReduction_554-happyReduction_554 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut216 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn215- (([mj AnnOpenC happy_var_1- ,mj AnnCloseC happy_var_3],happy_var_2)- )}}}--happyReduce_555 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_555 = happySpecReduce_3 199# happyReduction_555-happyReduction_555 happy_x_3- happy_x_2- happy_x_1- = case happyOut216 happy_x_2 of { happy_var_2 -> - happyIn215- (([],happy_var_2)- )}--happyReduce_556 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_556 = happySpecReduce_1 200# happyReduction_556-happyReduction_556 happy_x_1- = case happyOut76 happy_x_1 of { happy_var_1 -> - happyIn216- (cvTopDecls happy_var_1- )}--happyReduce_557 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_557 = happySpecReduce_1 200# happyReduction_557-happyReduction_557 happy_x_1- = case happyOut75 happy_x_1 of { happy_var_1 -> - happyIn216- (cvTopDecls happy_var_1- )}--happyReduce_558 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_558 = happySpecReduce_1 201# happyReduction_558-happyReduction_558 happy_x_1- = case happyOut200 happy_x_1 of { happy_var_1 -> - happyIn217- (happy_var_1- )}--happyReduce_559 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_559 = happySpecReduce_2 201# happyReduction_559-happyReduction_559 happy_x_2- happy_x_1- = case happyOut201 happy_x_1 of { happy_var_1 -> - case happyOut283 happy_x_2 of { happy_var_2 -> - happyIn217- (sLL happy_var_1 happy_var_2 $ SectionL happy_var_1 happy_var_2- )}}--happyReduce_560 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_560 = happySpecReduce_2 201# happyReduction_560-happyReduction_560 happy_x_2- happy_x_1- = case happyOut284 happy_x_1 of { happy_var_1 -> - case happyOut201 happy_x_2 of { happy_var_2 -> - happyIn217- (sLL happy_var_1 happy_var_2 $ SectionR happy_var_1 happy_var_2- )}}--happyReduce_561 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_561 = happyMonadReduce 3# 201# happyReduction_561-happyReduction_561 (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 { happy_var_2 -> - case happyOut217 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ EViewPat happy_var_1 happy_var_3) [mu AnnRarrow happy_var_2])}}})- ) (\r -> happyReturn (happyIn217 r))--happyReduce_562 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_562 = happyMonadReduce 2# 202# happyReduction_562-happyReduction_562 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOut219 happy_x_2 of { happy_var_2 -> - ( do { addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2)- ; return ([],Tuple ((sL1 happy_var_1 (Present happy_var_1)) : snd happy_var_2)) })}})- ) (\r -> happyReturn (happyIn218 r))--happyReduce_563 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_563 = happySpecReduce_2 202# happyReduction_563-happyReduction_563 happy_x_2- happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOut310 happy_x_2 of { happy_var_2 -> - happyIn218- ((mvbars (fst happy_var_2), Sum 1 (snd happy_var_2 + 1) happy_var_1)- )}}--happyReduce_564 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_564 = happyMonadReduce 2# 202# happyReduction_564-happyReduction_564 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut308 happy_x_1 of { happy_var_1 -> - case happyOut220 happy_x_2 of { happy_var_2 -> - ( do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (fst happy_var_1)- ; return- ([],Tuple (map (\l -> L l missingTupArg) (fst happy_var_1) ++ happy_var_2)) })}})- ) (\r -> happyReturn (happyIn218 r))--happyReduce_565 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_565 = happySpecReduce_3 202# happyReduction_565-happyReduction_565 happy_x_3- happy_x_2- happy_x_1- = case happyOut310 happy_x_1 of { happy_var_1 -> - case happyOut217 happy_x_2 of { happy_var_2 -> - case happyOut309 happy_x_3 of { happy_var_3 -> - happyIn218- ((mvbars (fst happy_var_1) ++ mvbars (fst happy_var_3), Sum (snd happy_var_1 + 1) (snd happy_var_1 + snd happy_var_3 + 1) happy_var_2)- )}}}--happyReduce_566 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_566 = happyMonadReduce 2# 203# happyReduction_566-happyReduction_566 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut308 happy_x_1 of { happy_var_1 -> - case happyOut220 happy_x_2 of { happy_var_2 -> - ( do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (tail $ fst happy_var_1)- ; return (- (head $ fst happy_var_1- ,(map (\l -> L l missingTupArg) (tail $ fst happy_var_1)) ++ happy_var_2)) })}})- ) (\r -> happyReturn (happyIn219 r))--happyReduce_567 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_567 = happyMonadReduce 2# 204# happyReduction_567-happyReduction_567 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOut219 happy_x_2 of { happy_var_2 -> - ( addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2) >>- return ((L (gl happy_var_1) (Present happy_var_1)) : snd happy_var_2))}})- ) (\r -> happyReturn (happyIn220 r))--happyReduce_568 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_568 = happySpecReduce_1 204# happyReduction_568-happyReduction_568 happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - happyIn220- ([L (gl happy_var_1) (Present happy_var_1)]- )}--happyReduce_569 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_569 = happySpecReduce_0 204# happyReduction_569-happyReduction_569 = happyIn220- ([noLoc missingTupArg]- )--happyReduce_570 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_570 = happySpecReduce_1 205# happyReduction_570-happyReduction_570 happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - happyIn221- (([],ExplicitList placeHolderType Nothing [happy_var_1])- )}--happyReduce_571 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_571 = happySpecReduce_1 205# happyReduction_571-happyReduction_571 happy_x_1- = case happyOut222 happy_x_1 of { happy_var_1 -> - happyIn221- (([],ExplicitList placeHolderType Nothing- (reverse (unLoc happy_var_1)))- )}--happyReduce_572 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_572 = happySpecReduce_2 205# happyReduction_572-happyReduction_572 happy_x_2- happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn221- (([mj AnnDotdot happy_var_2],- ArithSeq noPostTcExpr Nothing (From happy_var_1))- )}}--happyReduce_573 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_573 = happyReduce 4# 205# happyReduction_573-happyReduction_573 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn221- (([mj AnnComma happy_var_2,mj AnnDotdot happy_var_4],- ArithSeq noPostTcExpr Nothing- (FromThen happy_var_1 happy_var_3))- ) `HappyStk` happyRest}}}}--happyReduce_574 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_574 = happySpecReduce_3 205# happyReduction_574-happyReduction_574 happy_x_3- happy_x_2- happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - happyIn221- (([mj AnnDotdot happy_var_2],- ArithSeq noPostTcExpr Nothing- (FromTo happy_var_1 happy_var_3))- )}}}--happyReduce_575 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_575 = happyReduce 5# 205# happyReduction_575-happyReduction_575 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut200 happy_x_5 of { happy_var_5 -> - happyIn221- (([mj AnnComma happy_var_2,mj AnnDotdot happy_var_4],- ArithSeq noPostTcExpr Nothing- (FromThenTo happy_var_1 happy_var_3 happy_var_5))- ) `HappyStk` happyRest}}}}}--happyReduce_576 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_576 = happyMonadReduce 3# 205# happyReduction_576-happyReduction_576 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut223 happy_x_3 of { happy_var_3 -> - ( checkMonadComp >>= \ ctxt ->- return ([mj AnnVbar happy_var_2],- mkHsComp ctxt (unLoc happy_var_3) happy_var_1))}}})- ) (\r -> happyReturn (happyIn221 r))--happyReduce_577 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_577 = happyMonadReduce 3# 206# happyReduction_577-happyReduction_577 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut222 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut217 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1)- AnnComma (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 (((:) $! happy_var_3) $! unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn222 r))--happyReduce_578 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_578 = happyMonadReduce 3# 206# happyReduction_578-happyReduction_578 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut217 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 [happy_var_3,happy_var_1]))}}})- ) (\r -> happyReturn (happyIn222 r))--happyReduce_579 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_579 = happySpecReduce_1 207# happyReduction_579-happyReduction_579 happy_x_1- = case happyOut224 happy_x_1 of { happy_var_1 -> - happyIn223- (case (unLoc happy_var_1) of- [qs] -> sL1 happy_var_1 qs- -- We just had one thing in our "parallel" list so- -- we simply return that thing directly-- qss -> sL1 happy_var_1 [sL1 happy_var_1 $ ParStmt [ParStmtBlock qs [] noSyntaxExpr |- qs <- qss]- noExpr noSyntaxExpr placeHolderType]- -- We actually found some actual parallel lists so- -- we wrap them into as a ParStmt- )}--happyReduce_580 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_580 = happyMonadReduce 3# 208# happyReduction_580-happyReduction_580 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut225 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut224 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 (reverse (unLoc happy_var_1) : unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn224 r))--happyReduce_581 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_581 = happySpecReduce_1 208# happyReduction_581-happyReduction_581 happy_x_1- = case happyOut225 happy_x_1 of { happy_var_1 -> - happyIn224- (L (getLoc happy_var_1) [reverse (unLoc happy_var_1)]- )}--happyReduce_582 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_582 = happyMonadReduce 3# 209# happyReduction_582-happyReduction_582 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut225 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut226 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>- ams (sLL happy_var_1 happy_var_3 ()) (fst $ unLoc happy_var_3) >>- return (sLL happy_var_1 happy_var_3 [sLL happy_var_1 happy_var_3 ((snd $ unLoc happy_var_3) (reverse (unLoc happy_var_1)))]))}}})- ) (\r -> happyReturn (happyIn225 r))--happyReduce_583 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_583 = happyMonadReduce 3# 209# happyReduction_583-happyReduction_583 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut225 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut247 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn225 r))--happyReduce_584 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_584 = happyMonadReduce 1# 209# happyReduction_584-happyReduction_584 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut226 happy_x_1 of { happy_var_1 -> - ( ams happy_var_1 (fst $ unLoc happy_var_1) >>- return (sLL happy_var_1 happy_var_1 [L (getLoc happy_var_1) ((snd $ unLoc happy_var_1) [])]))})- ) (\r -> happyReturn (happyIn225 r))--happyReduce_585 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_585 = happySpecReduce_1 209# happyReduction_585-happyReduction_585 happy_x_1- = case happyOut247 happy_x_1 of { happy_var_1 -> - happyIn225- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_586 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_586 = happySpecReduce_2 210# happyReduction_586-happyReduction_586 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - happyIn226- (sLL happy_var_1 happy_var_2 ([mj AnnThen happy_var_1], \ss -> (mkTransformStmt ss happy_var_2))- )}}--happyReduce_587 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_587 = happyReduce 4# 210# happyReduction_587-happyReduction_587 (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 happyOut200 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - happyIn226- (sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnBy happy_var_3],\ss -> (mkTransformByStmt ss happy_var_2 happy_var_4))- ) `HappyStk` happyRest}}}}--happyReduce_588 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_588 = happyReduce 4# 210# happyReduction_588-happyReduction_588 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - happyIn226- (sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnUsing happy_var_3], \ss -> (mkGroupUsingStmt ss happy_var_4))- ) `HappyStk` happyRest}}}}--happyReduce_589 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_589 = happyReduce 6# 210# happyReduction_589-happyReduction_589 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut200 happy_x_6 of { happy_var_6 -> - happyIn226- (sLL happy_var_1 happy_var_6 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnBy happy_var_3,mj AnnUsing happy_var_5], \ss -> (mkGroupByUsingStmt ss happy_var_4 happy_var_6))- ) `HappyStk` happyRest}}}}}}--happyReduce_590 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_590 = happySpecReduce_0 211# happyReduction_590-happyReduction_590 = happyIn227- (([],ExplicitPArr placeHolderType [])- )--happyReduce_591 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_591 = happySpecReduce_1 211# happyReduction_591-happyReduction_591 happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - happyIn227- (([],ExplicitPArr placeHolderType [happy_var_1])- )}--happyReduce_592 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_592 = happySpecReduce_1 211# happyReduction_592-happyReduction_592 happy_x_1- = case happyOut222 happy_x_1 of { happy_var_1 -> - happyIn227- (([],ExplicitPArr placeHolderType- (reverse (unLoc happy_var_1)))- )}--happyReduce_593 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_593 = happySpecReduce_3 211# happyReduction_593-happyReduction_593 happy_x_3- happy_x_2- happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - happyIn227- (([mj AnnDotdot happy_var_2]- ,PArrSeq noPostTcExpr (FromTo happy_var_1 happy_var_3))- )}}}--happyReduce_594 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_594 = happyReduce 5# 211# happyReduction_594-happyReduction_594 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut200 happy_x_5 of { happy_var_5 -> - happyIn227- (([mj AnnComma happy_var_2,mj AnnDotdot happy_var_4]- ,PArrSeq noPostTcExpr (FromThenTo happy_var_1 happy_var_3 happy_var_5))- ) `HappyStk` happyRest}}}}}--happyReduce_595 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_595 = happySpecReduce_3 211# happyReduction_595-happyReduction_595 happy_x_3- happy_x_2- happy_x_1- = case happyOut217 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut223 happy_x_3 of { happy_var_3 -> - happyIn227- (([mj AnnVbar happy_var_2],mkHsComp PArrComp (unLoc happy_var_3) happy_var_1)- )}}}--happyReduce_596 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_596 = happySpecReduce_1 212# happyReduction_596-happyReduction_596 happy_x_1- = case happyOut229 happy_x_1 of { happy_var_1 -> - happyIn228- (L (getLoc happy_var_1) (reverse (unLoc happy_var_1))- )}--happyReduce_597 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_597 = happyMonadReduce 3# 213# happyReduction_597-happyReduction_597 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut229 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut247 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma- (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn229 r))--happyReduce_598 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_598 = happySpecReduce_1 213# happyReduction_598-happyReduction_598 happy_x_1- = case happyOut247 happy_x_1 of { happy_var_1 -> - happyIn229- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_599 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_599 = happySpecReduce_3 214# happyReduction_599-happyReduction_599 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut231 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn230- (sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))- ,(reverse (snd $ unLoc happy_var_2)))- )}}}--happyReduce_600 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_600 = happySpecReduce_3 214# happyReduction_600-happyReduction_600 happy_x_3- happy_x_2- happy_x_1- = case happyOut231 happy_x_2 of { happy_var_2 -> - happyIn230- (L (getLoc happy_var_2) (fst $ unLoc happy_var_2- ,(reverse (snd $ unLoc happy_var_2)))- )}--happyReduce_601 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_601 = happySpecReduce_2 214# happyReduction_601-happyReduction_601 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn230- (noLoc ([moc happy_var_1,mcc happy_var_2],[])- )}}--happyReduce_602 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_602 = happySpecReduce_2 214# happyReduction_602-happyReduction_602 happy_x_2- happy_x_1- = happyIn230- (noLoc ([],[])- )--happyReduce_603 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_603 = happySpecReduce_1 215# happyReduction_603-happyReduction_603 happy_x_1- = case happyOut232 happy_x_1 of { happy_var_1 -> - happyIn231- (sL1 happy_var_1 (fst $ unLoc happy_var_1,snd $ unLoc happy_var_1)- )}--happyReduce_604 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_604 = happySpecReduce_2 215# happyReduction_604-happyReduction_604 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut231 happy_x_2 of { happy_var_2 -> - happyIn231- (sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_1:(fst $ unLoc happy_var_2))- ,snd $ unLoc happy_var_2)- )}}--happyReduce_605 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_605 = happyMonadReduce 3# 216# happyReduction_605-happyReduction_605 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut232 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut233 happy_x_3 of { happy_var_3 -> - ( if null (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- ,[happy_var_3]))- else (ams (head $ snd $ unLoc happy_var_1)- (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))- >> return (sLL happy_var_1 happy_var_3 ([],happy_var_3 : (snd $ unLoc happy_var_1))) ))}}})- ) (\r -> happyReturn (happyIn232 r))--happyReduce_606 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_606 = happyMonadReduce 2# 216# happyReduction_606-happyReduction_606 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut232 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if null (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- ,snd $ unLoc happy_var_1))- else (ams (head $ snd $ unLoc happy_var_1)- (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))- >> return (sLL happy_var_1 happy_var_2 ([],snd $ unLoc happy_var_1))))}})- ) (\r -> happyReturn (happyIn232 r))--happyReduce_607 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_607 = happySpecReduce_1 216# happyReduction_607-happyReduction_607 happy_x_1- = case happyOut233 happy_x_1 of { happy_var_1 -> - happyIn232- (sL1 happy_var_1 ([],[happy_var_1])- )}--happyReduce_608 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_608 = happyMonadReduce 3# 217# happyReduction_608-happyReduction_608 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut239 happy_x_1 of { happy_var_1 -> - case happyOut142 happy_x_2 of { happy_var_2 -> - case happyOut234 happy_x_3 of { happy_var_3 -> - (ams (sLL happy_var_1 happy_var_3 (Match { m_ctxt = CaseAlt- , m_pats = [happy_var_1]- , m_type = snd happy_var_2- , m_grhss = snd $ unLoc happy_var_3 }))- (fst happy_var_2 ++ (fst $ unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn233 r))--happyReduce_609 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_609 = happySpecReduce_2 218# happyReduction_609-happyReduction_609 happy_x_2- happy_x_1- = case happyOut235 happy_x_1 of { happy_var_1 -> - case happyOut122 happy_x_2 of { happy_var_2 -> - happyIn234- (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_2,- GRHSs (unLoc happy_var_1) (snd $ unLoc happy_var_2))- )}}--happyReduce_610 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_610 = happyMonadReduce 2# 219# happyReduction_610-happyReduction_610 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 (unguardedRHS (comb2 happy_var_1 happy_var_2) happy_var_2))- [mu AnnRarrow happy_var_1])}})- ) (\r -> happyReturn (happyIn235 r))--happyReduce_611 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_611 = happySpecReduce_1 219# happyReduction_611-happyReduction_611 happy_x_1- = case happyOut236 happy_x_1 of { happy_var_1 -> - happyIn235- (sL1 happy_var_1 (reverse (unLoc happy_var_1))- )}--happyReduce_612 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_612 = happySpecReduce_2 220# happyReduction_612-happyReduction_612 happy_x_2- happy_x_1- = case happyOut236 happy_x_1 of { happy_var_1 -> - case happyOut238 happy_x_2 of { happy_var_2 -> - happyIn236- (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)- )}}--happyReduce_613 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_613 = happySpecReduce_1 220# happyReduction_613-happyReduction_613 happy_x_1- = case happyOut238 happy_x_1 of { happy_var_1 -> - happyIn236- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_614 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_614 = happySpecReduce_3 221# happyReduction_614-happyReduction_614 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut236 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn237- (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3],unLoc happy_var_2)- )}}}--happyReduce_615 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_615 = happySpecReduce_2 221# happyReduction_615-happyReduction_615 happy_x_2- happy_x_1- = case happyOut236 happy_x_1 of { happy_var_1 -> - happyIn237- (sL1 happy_var_1 ([],unLoc happy_var_1)- )}--happyReduce_616 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_616 = happyMonadReduce 4# 222# happyReduction_616-happyReduction_616 (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 happyOut228 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_4 of { happy_var_4 -> - ( ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS (unLoc happy_var_2) happy_var_4)- [mj AnnVbar happy_var_1,mu AnnRarrow happy_var_3])}}}})- ) (\r -> happyReturn (happyIn238 r))--happyReduce_617 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_617 = happyMonadReduce 1# 223# happyReduction_617-happyReduction_617 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut200 happy_x_1 of { happy_var_1 -> - ( checkPattern empty happy_var_1)})- ) (\r -> happyReturn (happyIn239 r))--happyReduce_618 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_618 = happyMonadReduce 2# 223# happyReduction_618-happyReduction_618 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut209 happy_x_2 of { happy_var_2 -> - ( amms (checkPattern empty (sLL happy_var_1 happy_var_2 (SectionR- (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)))- [mj AnnBang happy_var_1])}})- ) (\r -> happyReturn (happyIn239 r))--happyReduce_619 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_619 = happyMonadReduce 1# 224# happyReduction_619-happyReduction_619 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut200 happy_x_1 of { happy_var_1 -> - ( checkPattern- (text "Possibly caused by a missing 'do'?") happy_var_1)})- ) (\r -> happyReturn (happyIn240 r))--happyReduce_620 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_620 = happyMonadReduce 2# 224# happyReduction_620-happyReduction_620 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut209 happy_x_2 of { happy_var_2 -> - ( amms (checkPattern- (text "Possibly caused by a missing 'do'?")- (sLL happy_var_1 happy_var_2 (SectionR (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)))- [mj AnnBang happy_var_1])}})- ) (\r -> happyReturn (happyIn240 r))--happyReduce_621 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_621 = happyMonadReduce 1# 225# happyReduction_621-happyReduction_621 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut209 happy_x_1 of { happy_var_1 -> - ( checkPattern empty happy_var_1)})- ) (\r -> happyReturn (happyIn241 r))--happyReduce_622 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_622 = happyMonadReduce 2# 225# happyReduction_622-happyReduction_622 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut209 happy_x_2 of { happy_var_2 -> - ( amms (checkPattern empty- (sLL happy_var_1 happy_var_2 (SectionR- (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)))- [mj AnnBang happy_var_1])}})- ) (\r -> happyReturn (happyIn241 r))--happyReduce_623 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_623 = happySpecReduce_2 226# happyReduction_623-happyReduction_623 happy_x_2- happy_x_1- = case happyOut241 happy_x_1 of { happy_var_1 -> - case happyOut242 happy_x_2 of { happy_var_2 -> - happyIn242- (happy_var_1 : happy_var_2- )}}--happyReduce_624 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_624 = happySpecReduce_0 226# happyReduction_624-happyReduction_624 = happyIn242- ([]- )--happyReduce_625 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_625 = happySpecReduce_3 227# happyReduction_625-happyReduction_625 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut244 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn243- (sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))- ,(reverse $ snd $ unLoc happy_var_2))- )}}}--happyReduce_626 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_626 = happySpecReduce_3 227# happyReduction_626-happyReduction_626 happy_x_3- happy_x_2- happy_x_1- = case happyOut244 happy_x_2 of { happy_var_2 -> - happyIn243- (L (gl happy_var_2) (fst $ unLoc happy_var_2- ,reverse $ snd $ unLoc happy_var_2)- )}--happyReduce_627 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_627 = happyMonadReduce 3# 228# happyReduction_627-happyReduction_627 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut244 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut246 happy_x_3 of { happy_var_3 -> - ( if null (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)- ,happy_var_3 : (snd $ unLoc happy_var_1)))- else do- { ams (head $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]- ; return $ sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,happy_var_3 :(snd $ unLoc happy_var_1)) })}}})- ) (\r -> happyReturn (happyIn244 r))--happyReduce_628 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_628 = happyMonadReduce 2# 228# happyReduction_628-happyReduction_628 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut244 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if null (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1),snd $ unLoc happy_var_1))- else do- { ams (head $ snd $ unLoc happy_var_1)- [mj AnnSemi happy_var_2]- ; return happy_var_1 })}})- ) (\r -> happyReturn (happyIn244 r))--happyReduce_629 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_629 = happySpecReduce_1 228# happyReduction_629-happyReduction_629 happy_x_1- = case happyOut246 happy_x_1 of { happy_var_1 -> - happyIn244- (sL1 happy_var_1 ([],[happy_var_1])- )}--happyReduce_630 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_630 = happySpecReduce_0 228# happyReduction_630-happyReduction_630 = happyIn244- (noLoc ([],[])- )--happyReduce_631 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_631 = happySpecReduce_1 229# happyReduction_631-happyReduction_631 happy_x_1- = case happyOut246 happy_x_1 of { happy_var_1 -> - happyIn245- (Just happy_var_1- )}--happyReduce_632 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_632 = happySpecReduce_0 229# happyReduction_632-happyReduction_632 = happyIn245- (Nothing- )--happyReduce_633 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_633 = happySpecReduce_1 230# happyReduction_633-happyReduction_633 happy_x_1- = case happyOut247 happy_x_1 of { happy_var_1 -> - happyIn246- (happy_var_1- )}--happyReduce_634 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_634 = happyMonadReduce 2# 230# happyReduction_634-happyReduction_634 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut243 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ mkRecStmt (snd $ unLoc happy_var_2))- (mj AnnRec happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn246 r))--happyReduce_635 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_635 = happyMonadReduce 3# 231# happyReduction_635-happyReduction_635 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut240 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ mkBindStmt happy_var_1 happy_var_3)- [mu AnnLarrow happy_var_2])}}})- ) (\r -> happyReturn (happyIn247 r))--happyReduce_636 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_636 = happySpecReduce_1 231# happyReduction_636-happyReduction_636 happy_x_1- = case happyOut200 happy_x_1 of { happy_var_1 -> - happyIn247- (sL1 happy_var_1 $ mkBodyStmt happy_var_1- )}--happyReduce_637 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_637 = happyMonadReduce 2# 231# happyReduction_637-happyReduction_637 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut121 happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2$ LetStmt (snd $ unLoc happy_var_2))- (mj AnnLet happy_var_1:(fst $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn247 r))--happyReduce_638 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_638 = happySpecReduce_1 232# happyReduction_638-happyReduction_638 happy_x_1- = case happyOut249 happy_x_1 of { happy_var_1 -> - happyIn248- (happy_var_1- )}--happyReduce_639 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_639 = happySpecReduce_0 232# happyReduction_639-happyReduction_639 = happyIn248- (([],([], False))- )--happyReduce_640 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_640 = happyMonadReduce 3# 233# happyReduction_640-happyReduction_640 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut250 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut249 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>- return (case happy_var_3 of (ma,(flds, dd)) -> (ma,(happy_var_1 : flds, dd))))}}})- ) (\r -> happyReturn (happyIn249 r))--happyReduce_641 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_641 = happySpecReduce_1 233# happyReduction_641-happyReduction_641 happy_x_1- = case happyOut250 happy_x_1 of { happy_var_1 -> - happyIn249- (([],([happy_var_1], False))- )}--happyReduce_642 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_642 = happySpecReduce_1 233# happyReduction_642-happyReduction_642 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn249- (([mj AnnDotdot happy_var_1],([], True))- )}--happyReduce_643 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_643 = happyMonadReduce 3# 234# happyReduction_643-happyReduction_643 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut291 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut217 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) happy_var_3 False)- [mj AnnEqual happy_var_2])}}})- ) (\r -> happyReturn (happyIn250 r))--happyReduce_644 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_644 = happySpecReduce_1 234# happyReduction_644-happyReduction_644 happy_x_1- = case happyOut291 happy_x_1 of { happy_var_1 -> - happyIn250- (sLL happy_var_1 happy_var_1 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) placeHolderPunRhs True- )}--happyReduce_645 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_645 = happyMonadReduce 3# 235# happyReduction_645-happyReduction_645 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut251 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut252 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>- return (let { this = happy_var_3; rest = unLoc happy_var_1 }- in rest `seq` this `seq` sLL happy_var_1 happy_var_3 (this : rest)))}}})- ) (\r -> happyReturn (happyIn251 r))--happyReduce_646 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_646 = happyMonadReduce 2# 235# happyReduction_646-happyReduction_646 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut251 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})- ) (\r -> happyReturn (happyIn251 r))--happyReduce_647 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_647 = happySpecReduce_1 235# happyReduction_647-happyReduction_647 happy_x_1- = case happyOut252 happy_x_1 of { happy_var_1 -> - happyIn251- (let this = happy_var_1 in this `seq` sL1 happy_var_1 [this]- )}--happyReduce_648 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_648 = happyMonadReduce 3# 236# happyReduction_648-happyReduction_648 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut253 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (IPBind (Left happy_var_1) happy_var_3))- [mj AnnEqual happy_var_2])}}})- ) (\r -> happyReturn (happyIn252 r))--happyReduce_649 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_649 = happySpecReduce_1 237# happyReduction_649-happyReduction_649 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn253- (sL1 happy_var_1 (HsIPName (getIPDUPVARID happy_var_1))- )}--happyReduce_650 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_650 = happySpecReduce_1 238# happyReduction_650-happyReduction_650 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn254- (sL1 happy_var_1 (getLABELVARID happy_var_1)- )}--happyReduce_651 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_651 = happySpecReduce_1 239# happyReduction_651-happyReduction_651 happy_x_1- = case happyOut256 happy_x_1 of { happy_var_1 -> - happyIn255- (happy_var_1- )}--happyReduce_652 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_652 = happySpecReduce_0 239# happyReduction_652-happyReduction_652 = happyIn255- (noLoc mkTrue- )--happyReduce_653 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_653 = happySpecReduce_1 240# happyReduction_653-happyReduction_653 happy_x_1- = case happyOut257 happy_x_1 of { happy_var_1 -> - happyIn256- (happy_var_1- )}--happyReduce_654 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_654 = happyMonadReduce 3# 240# happyReduction_654-happyReduction_654 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut257 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut256 happy_x_3 of { happy_var_3 -> - ( aa happy_var_1 (AnnVbar, happy_var_2)- >> return (sLL happy_var_1 happy_var_3 (Or [happy_var_1,happy_var_3])))}}})- ) (\r -> happyReturn (happyIn256 r))--happyReduce_655 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_655 = happySpecReduce_1 241# happyReduction_655-happyReduction_655 happy_x_1- = case happyOut258 happy_x_1 of { happy_var_1 -> - happyIn257- (sLL (head happy_var_1) (last happy_var_1) (And (happy_var_1))- )}--happyReduce_656 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_656 = happySpecReduce_1 242# happyReduction_656-happyReduction_656 happy_x_1- = case happyOut259 happy_x_1 of { happy_var_1 -> - happyIn258- ([happy_var_1]- )}--happyReduce_657 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_657 = happyMonadReduce 3# 242# happyReduction_657-happyReduction_657 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut259 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut258 happy_x_3 of { happy_var_3 -> - ( aa happy_var_1 (AnnComma, happy_var_2) >> return (happy_var_1 : happy_var_3))}}})- ) (\r -> happyReturn (happyIn258 r))--happyReduce_658 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_658 = happyMonadReduce 3# 243# happyReduction_658-happyReduction_658 (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 happyOut256 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (Parens happy_var_2)) [mop happy_var_1,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn259 r))--happyReduce_659 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_659 = happySpecReduce_1 243# happyReduction_659-happyReduction_659 happy_x_1- = case happyOut261 happy_x_1 of { happy_var_1 -> - happyIn259- (sL1 happy_var_1 (Var happy_var_1)- )}--happyReduce_660 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_660 = happySpecReduce_1 244# happyReduction_660-happyReduction_660 happy_x_1- = case happyOut261 happy_x_1 of { happy_var_1 -> - happyIn260- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_661 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_661 = happyMonadReduce 3# 244# happyReduction_661-happyReduction_661 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut261 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut260 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn260 r))--happyReduce_662 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_662 = happySpecReduce_1 245# happyReduction_662-happyReduction_662 happy_x_1- = case happyOut290 happy_x_1 of { happy_var_1 -> - happyIn261- (happy_var_1- )}--happyReduce_663 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_663 = happySpecReduce_1 245# happyReduction_663-happyReduction_663 happy_x_1- = case happyOut265 happy_x_1 of { happy_var_1 -> - happyIn261- (happy_var_1- )}--happyReduce_664 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_664 = happySpecReduce_1 246# happyReduction_664-happyReduction_664 happy_x_1- = case happyOut264 happy_x_1 of { happy_var_1 -> - happyIn262- (happy_var_1- )}--happyReduce_665 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_665 = happySpecReduce_1 246# happyReduction_665-happyReduction_665 happy_x_1- = case happyOut267 happy_x_1 of { happy_var_1 -> - happyIn262- (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))- )}--happyReduce_666 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_666 = happySpecReduce_1 247# happyReduction_666-happyReduction_666 happy_x_1- = case happyOut264 happy_x_1 of { happy_var_1 -> - happyIn263- (happy_var_1- )}--happyReduce_667 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_667 = happySpecReduce_1 247# happyReduction_667-happyReduction_667 happy_x_1- = case happyOut268 happy_x_1 of { happy_var_1 -> - happyIn263- (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))- )}--happyReduce_668 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_668 = happySpecReduce_1 248# happyReduction_668-happyReduction_668 happy_x_1- = case happyOut301 happy_x_1 of { happy_var_1 -> - happyIn264- (happy_var_1- )}--happyReduce_669 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_669 = happyMonadReduce 3# 248# happyReduction_669-happyReduction_669 (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 happyOut303 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn264 r))--happyReduce_670 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_670 = happySpecReduce_1 249# happyReduction_670-happyReduction_670 happy_x_1- = case happyOut302 happy_x_1 of { happy_var_1 -> - happyIn265- (happy_var_1- )}--happyReduce_671 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_671 = happyMonadReduce 3# 249# happyReduction_671-happyReduction_671 (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 happyOut304 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn265 r))--happyReduce_672 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_672 = happySpecReduce_1 249# happyReduction_672-happyReduction_672 happy_x_1- = case happyOut268 happy_x_1 of { happy_var_1 -> - happyIn265- (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))- )}--happyReduce_673 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_673 = happySpecReduce_1 250# happyReduction_673-happyReduction_673 happy_x_1- = case happyOut265 happy_x_1 of { happy_var_1 -> - happyIn266- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_674 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_674 = happyMonadReduce 3# 250# happyReduction_674-happyReduction_674 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut265 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut266 happy_x_3 of { happy_var_3 -> - ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>- return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn266 r))--happyReduce_675 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_675 = happyMonadReduce 2# 251# happyReduction_675-happyReduction_675 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 unitDataCon) [mop happy_var_1,mcp happy_var_2])}})- ) (\r -> happyReturn (happyIn267 r))--happyReduce_676 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_676 = happyMonadReduce 3# 251# happyReduction_676-happyReduction_676 (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 happyOut308 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Boxed (snd happy_var_2 + 1))- (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})- ) (\r -> happyReturn (happyIn267 r))--happyReduce_677 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_677 = happyMonadReduce 2# 251# happyReduction_677-happyReduction_677 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ unboxedUnitDataCon) [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn267 r))--happyReduce_678 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_678 = happyMonadReduce 3# 251# happyReduction_678-happyReduction_678 (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 happyOut308 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Unboxed (snd happy_var_2 + 1))- (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})- ) (\r -> happyReturn (happyIn267 r))--happyReduce_679 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_679 = happySpecReduce_1 252# happyReduction_679-happyReduction_679 happy_x_1- = case happyOut267 happy_x_1 of { happy_var_1 -> - happyIn268- (happy_var_1- )}--happyReduce_680 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_680 = happyMonadReduce 2# 252# happyReduction_680-happyReduction_680 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 nilDataCon) [mos happy_var_1,mcs happy_var_2])}})- ) (\r -> happyReturn (happyIn268 r))--happyReduce_681 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_681 = happySpecReduce_1 253# happyReduction_681-happyReduction_681 happy_x_1- = case happyOut304 happy_x_1 of { happy_var_1 -> - happyIn269- (happy_var_1- )}--happyReduce_682 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_682 = happyMonadReduce 3# 253# happyReduction_682-happyReduction_682 (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 happyOut302 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn269 r))--happyReduce_683 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_683 = happySpecReduce_1 254# happyReduction_683-happyReduction_683 happy_x_1- = case happyOut303 happy_x_1 of { happy_var_1 -> - happyIn270- (happy_var_1- )}--happyReduce_684 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_684 = happyMonadReduce 3# 254# happyReduction_684-happyReduction_684 (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 happyOut301 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn270 r))--happyReduce_685 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_685 = happySpecReduce_1 255# happyReduction_685-happyReduction_685 happy_x_1- = case happyOut272 happy_x_1 of { happy_var_1 -> - happyIn271- (happy_var_1- )}--happyReduce_686 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_686 = happyMonadReduce 2# 255# happyReduction_686-happyReduction_686 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ getRdrName unitTyCon)- [mop happy_var_1,mcp happy_var_2])}})- ) (\r -> happyReturn (happyIn271 r))--happyReduce_687 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_687 = happyMonadReduce 2# 255# happyReduction_687-happyReduction_687 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ getRdrName unboxedUnitTyCon)- [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn271 r))--happyReduce_688 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_688 = happySpecReduce_1 256# happyReduction_688-happyReduction_688 happy_x_1- = case happyOut273 happy_x_1 of { happy_var_1 -> - happyIn272- (happy_var_1- )}--happyReduce_689 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_689 = happyMonadReduce 3# 256# happyReduction_689-happyReduction_689 (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 happyOut308 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Boxed- (snd happy_var_2 + 1)))- (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})- ) (\r -> happyReturn (happyIn272 r))--happyReduce_690 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_690 = happyMonadReduce 3# 256# happyReduction_690-happyReduction_690 (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 happyOut308 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Unboxed- (snd happy_var_2 + 1)))- (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})- ) (\r -> happyReturn (happyIn272 r))--happyReduce_691 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_691 = happyMonadReduce 3# 256# happyReduction_691-happyReduction_691 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)- [mop happy_var_1,mu AnnRarrow happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn272 r))--happyReduce_692 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_692 = happyMonadReduce 2# 256# happyReduction_692-happyReduction_692 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ listTyCon_RDR) [mos happy_var_1,mcs happy_var_2])}})- ) (\r -> happyReturn (happyIn272 r))--happyReduce_693 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_693 = happyMonadReduce 2# 256# happyReduction_693-happyReduction_693 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( ams (sLL happy_var_1 happy_var_2 $ parrTyCon_RDR) [mo happy_var_1,mc happy_var_2])}})- ) (\r -> happyReturn (happyIn272 r))--happyReduce_694 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_694 = happyMonadReduce 3# 256# happyReduction_694-happyReduction_694 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ getRdrName eqPrimTyCon)- [mop happy_var_1,mj AnnTildehsh happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn272 r))--happyReduce_695 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_695 = happySpecReduce_1 257# happyReduction_695-happyReduction_695 happy_x_1- = case happyOut276 happy_x_1 of { happy_var_1 -> - happyIn273- (happy_var_1- )}--happyReduce_696 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_696 = happyMonadReduce 3# 257# happyReduction_696-happyReduction_696 (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 happyOut279 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn273 r))--happyReduce_697 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_697 = happyMonadReduce 3# 257# happyReduction_697-happyReduction_697 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ eqTyCon_RDR)- [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn273 r))--happyReduce_698 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_698 = happySpecReduce_1 258# happyReduction_698-happyReduction_698 happy_x_1- = case happyOut276 happy_x_1 of { happy_var_1 -> - happyIn274- (happy_var_1- )}--happyReduce_699 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_699 = happyMonadReduce 3# 258# happyReduction_699-happyReduction_699 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( let name = sL1 happy_var_2 $! mkQual tcClsName (getQCONSYM happy_var_2)- in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn274 r))--happyReduce_700 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_700 = happyMonadReduce 3# 258# happyReduction_700-happyReduction_700 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( let name = sL1 happy_var_2 $! mkUnqual tcClsName (getCONSYM happy_var_2)- in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn274 r))--happyReduce_701 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_701 = happyMonadReduce 3# 258# happyReduction_701-happyReduction_701 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( let name = sL1 happy_var_2 $! consDataCon_RDR- in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn274 r))--happyReduce_702 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_702 = happyMonadReduce 3# 258# happyReduction_702-happyReduction_702 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 $ eqTyCon_RDR) [mop happy_var_1,mj AnnTilde happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn274 r))--happyReduce_703 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_703 = happySpecReduce_1 259# happyReduction_703-happyReduction_703 happy_x_1- = case happyOut279 happy_x_1 of { happy_var_1 -> - happyIn275- (happy_var_1- )}--happyReduce_704 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_704 = happyMonadReduce 3# 259# happyReduction_704-happyReduction_704 (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 happyOut276 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn275 r))--happyReduce_705 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_705 = happySpecReduce_1 260# happyReduction_705-happyReduction_705 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn276- (sL1 happy_var_1 $! mkQual tcClsName (getQCONID happy_var_1)- )}--happyReduce_706 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_706 = happySpecReduce_1 260# happyReduction_706-happyReduction_706 happy_x_1- = case happyOut278 happy_x_1 of { happy_var_1 -> - happyIn276- (happy_var_1- )}--happyReduce_707 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_707 = happySpecReduce_1 261# happyReduction_707-happyReduction_707 happy_x_1- = case happyOut276 happy_x_1 of { happy_var_1 -> - happyIn277- (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)- )}--happyReduce_708 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_708 = happySpecReduce_2 261# happyReduction_708-happyReduction_708 happy_x_2- happy_x_1- = case happyOut276 happy_x_1 of { happy_var_1 -> - case happyOut312 happy_x_2 of { happy_var_2 -> - happyIn277- (sLL happy_var_1 happy_var_2 (HsDocTy (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)) happy_var_2)- )}}--happyReduce_709 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_709 = happySpecReduce_1 262# happyReduction_709-happyReduction_709 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn278- (sL1 happy_var_1 $! mkUnqual tcClsName (getCONID happy_var_1)- )}--happyReduce_710 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_710 = happySpecReduce_1 263# happyReduction_710-happyReduction_710 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn279- (sL1 happy_var_1 $! mkQual tcClsName (getQCONSYM happy_var_1)- )}--happyReduce_711 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_711 = happySpecReduce_1 263# happyReduction_711-happyReduction_711 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn279- (sL1 happy_var_1 $! mkQual tcClsName (getQVARSYM happy_var_1)- )}--happyReduce_712 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_712 = happySpecReduce_1 263# happyReduction_712-happyReduction_712 happy_x_1- = case happyOut280 happy_x_1 of { happy_var_1 -> - happyIn279- (happy_var_1- )}--happyReduce_713 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_713 = happySpecReduce_1 264# happyReduction_713-happyReduction_713 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn280- (sL1 happy_var_1 $! mkUnqual tcClsName (getCONSYM happy_var_1)- )}--happyReduce_714 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_714 = happySpecReduce_1 264# happyReduction_714-happyReduction_714 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn280- (sL1 happy_var_1 $! mkUnqual tcClsName (getVARSYM happy_var_1)- )}--happyReduce_715 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_715 = happySpecReduce_1 264# happyReduction_715-happyReduction_715 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn280- (sL1 happy_var_1 $! consDataCon_RDR- )}--happyReduce_716 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_716 = happySpecReduce_1 264# happyReduction_716-happyReduction_716 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn280- (sL1 happy_var_1 $! mkUnqual tcClsName (fsLit "-")- )}--happyReduce_717 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_717 = happySpecReduce_1 265# happyReduction_717-happyReduction_717 happy_x_1- = case happyOut282 happy_x_1 of { happy_var_1 -> - happyIn281- (happy_var_1- )}--happyReduce_718 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_718 = happySpecReduce_1 265# happyReduction_718-happyReduction_718 happy_x_1- = case happyOut269 happy_x_1 of { happy_var_1 -> - happyIn281- (happy_var_1- )}--happyReduce_719 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_719 = happySpecReduce_1 266# happyReduction_719-happyReduction_719 happy_x_1- = case happyOut297 happy_x_1 of { happy_var_1 -> - happyIn282- (happy_var_1- )}--happyReduce_720 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_720 = happyMonadReduce 3# 266# happyReduction_720-happyReduction_720 (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 happyOut293 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn282 r))--happyReduce_721 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_721 = happySpecReduce_1 267# happyReduction_721-happyReduction_721 happy_x_1- = case happyOut285 happy_x_1 of { happy_var_1 -> - happyIn283- (sL1 happy_var_1 $ HsVar happy_var_1- )}--happyReduce_722 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_722 = happySpecReduce_1 267# happyReduction_722-happyReduction_722 happy_x_1- = case happyOut270 happy_x_1 of { happy_var_1 -> - happyIn283- (sL1 happy_var_1 $ HsVar happy_var_1- )}--happyReduce_723 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_723 = happyMonadReduce 3# 267# happyReduction_723-happyReduction_723 (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 happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 EWildPat)- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn283 r))--happyReduce_724 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_724 = happySpecReduce_1 268# happyReduction_724-happyReduction_724 happy_x_1- = case happyOut286 happy_x_1 of { happy_var_1 -> - happyIn284- (sL1 happy_var_1 $ HsVar happy_var_1- )}--happyReduce_725 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_725 = happySpecReduce_1 268# happyReduction_725-happyReduction_725 happy_x_1- = case happyOut270 happy_x_1 of { happy_var_1 -> - happyIn284- (sL1 happy_var_1 $ HsVar happy_var_1- )}--happyReduce_726 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_726 = happySpecReduce_1 269# happyReduction_726-happyReduction_726 happy_x_1- = case happyOut294 happy_x_1 of { happy_var_1 -> - happyIn285- (happy_var_1- )}--happyReduce_727 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_727 = happyMonadReduce 3# 269# happyReduction_727-happyReduction_727 (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 happyOut292 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn285 r))--happyReduce_728 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_728 = happySpecReduce_1 270# happyReduction_728-happyReduction_728 happy_x_1- = case happyOut295 happy_x_1 of { happy_var_1 -> - happyIn286- (happy_var_1- )}--happyReduce_729 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_729 = happyMonadReduce 3# 270# happyReduction_729-happyReduction_729 (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 happyOut292 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn286 r))--happyReduce_730 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_730 = happySpecReduce_1 271# happyReduction_730-happyReduction_730 happy_x_1- = case happyOut289 happy_x_1 of { happy_var_1 -> - happyIn287- (happy_var_1- )}--happyReduce_731 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_731 = happyMonadReduce 3# 272# happyReduction_731-happyReduction_731 (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 happyOut289 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2- ,mj AnnBackquote happy_var_3])}}})- ) (\r -> happyReturn (happyIn288 r))--happyReduce_732 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_732 = happyMonadReduce 1# 272# happyReduction_732-happyReduction_732 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( hintExplicitForall' (getLoc happy_var_1))})- ) (\r -> happyReturn (happyIn288 r))--happyReduce_733 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_733 = happySpecReduce_1 273# happyReduction_733-happyReduction_733 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn289- (sL1 happy_var_1 $! mkUnqual tvName (getVARID happy_var_1)- )}--happyReduce_734 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_734 = happySpecReduce_1 273# happyReduction_734-happyReduction_734 happy_x_1- = case happyOut299 happy_x_1 of { happy_var_1 -> - happyIn289- (sL1 happy_var_1 $! mkUnqual tvName (unLoc happy_var_1)- )}--happyReduce_735 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_735 = happySpecReduce_1 273# happyReduction_735-happyReduction_735 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn289- (sL1 happy_var_1 $! mkUnqual tvName (fsLit "unsafe")- )}--happyReduce_736 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_736 = happySpecReduce_1 273# happyReduction_736-happyReduction_736 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn289- (sL1 happy_var_1 $! mkUnqual tvName (fsLit "safe")- )}--happyReduce_737 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_737 = happySpecReduce_1 273# happyReduction_737-happyReduction_737 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn289- (sL1 happy_var_1 $! mkUnqual tvName (fsLit "interruptible")- )}--happyReduce_738 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_738 = happySpecReduce_1 274# happyReduction_738-happyReduction_738 happy_x_1- = case happyOut293 happy_x_1 of { happy_var_1 -> - happyIn290- (happy_var_1- )}--happyReduce_739 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_739 = happyMonadReduce 3# 274# happyReduction_739-happyReduction_739 (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 happyOut297 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn290 r))--happyReduce_740 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_740 = happySpecReduce_1 275# happyReduction_740-happyReduction_740 happy_x_1- = case happyOut292 happy_x_1 of { happy_var_1 -> - happyIn291- (happy_var_1- )}--happyReduce_741 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_741 = happyMonadReduce 3# 275# happyReduction_741-happyReduction_741 (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 happyOut297 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn291 r))--happyReduce_742 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_742 = happyMonadReduce 3# 275# happyReduction_742-happyReduction_742 (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 happyOut296 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})- ) (\r -> happyReturn (happyIn291 r))--happyReduce_743 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_743 = happySpecReduce_1 276# happyReduction_743-happyReduction_743 happy_x_1- = case happyOut293 happy_x_1 of { happy_var_1 -> - happyIn292- (happy_var_1- )}--happyReduce_744 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_744 = happySpecReduce_1 276# happyReduction_744-happyReduction_744 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn292- (sL1 happy_var_1 $! mkQual varName (getQVARID happy_var_1)- )}--happyReduce_745 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_745 = happySpecReduce_1 277# happyReduction_745-happyReduction_745 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (getVARID happy_var_1)- )}--happyReduce_746 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_746 = happySpecReduce_1 277# happyReduction_746-happyReduction_746 happy_x_1- = case happyOut299 happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (unLoc happy_var_1)- )}--happyReduce_747 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_747 = happySpecReduce_1 277# happyReduction_747-happyReduction_747 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (fsLit "unsafe")- )}--happyReduce_748 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_748 = happySpecReduce_1 277# happyReduction_748-happyReduction_748 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (fsLit "safe")- )}--happyReduce_749 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_749 = happySpecReduce_1 277# happyReduction_749-happyReduction_749 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (fsLit "interruptible")- )}--happyReduce_750 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_750 = happySpecReduce_1 277# happyReduction_750-happyReduction_750 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (fsLit "forall")- )}--happyReduce_751 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_751 = happySpecReduce_1 277# happyReduction_751-happyReduction_751 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (fsLit "family")- )}--happyReduce_752 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_752 = happySpecReduce_1 277# happyReduction_752-happyReduction_752 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn293- (sL1 happy_var_1 $! mkUnqual varName (fsLit "role")- )}--happyReduce_753 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_753 = happySpecReduce_1 278# happyReduction_753-happyReduction_753 happy_x_1- = case happyOut297 happy_x_1 of { happy_var_1 -> - happyIn294- (happy_var_1- )}--happyReduce_754 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_754 = happySpecReduce_1 278# happyReduction_754-happyReduction_754 happy_x_1- = case happyOut296 happy_x_1 of { happy_var_1 -> - happyIn294- (happy_var_1- )}--happyReduce_755 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_755 = happySpecReduce_1 279# happyReduction_755-happyReduction_755 happy_x_1- = case happyOut298 happy_x_1 of { happy_var_1 -> - happyIn295- (happy_var_1- )}--happyReduce_756 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_756 = happySpecReduce_1 279# happyReduction_756-happyReduction_756 happy_x_1- = case happyOut296 happy_x_1 of { happy_var_1 -> - happyIn295- (happy_var_1- )}--happyReduce_757 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_757 = happySpecReduce_1 280# happyReduction_757-happyReduction_757 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn296- (sL1 happy_var_1 $ mkQual varName (getQVARSYM happy_var_1)- )}--happyReduce_758 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_758 = happySpecReduce_1 281# happyReduction_758-happyReduction_758 happy_x_1- = case happyOut298 happy_x_1 of { happy_var_1 -> - happyIn297- (happy_var_1- )}--happyReduce_759 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_759 = happySpecReduce_1 281# happyReduction_759-happyReduction_759 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn297- (sL1 happy_var_1 $ mkUnqual varName (fsLit "-")- )}--happyReduce_760 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_760 = happySpecReduce_1 282# happyReduction_760-happyReduction_760 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn298- (sL1 happy_var_1 $ mkUnqual varName (getVARSYM happy_var_1)- )}--happyReduce_761 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_761 = happySpecReduce_1 282# happyReduction_761-happyReduction_761 happy_x_1- = case happyOut300 happy_x_1 of { happy_var_1 -> - happyIn298- (sL1 happy_var_1 $ mkUnqual varName (unLoc happy_var_1)- )}--happyReduce_762 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_762 = happySpecReduce_1 283# happyReduction_762-happyReduction_762 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "as")- )}--happyReduce_763 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_763 = happySpecReduce_1 283# happyReduction_763-happyReduction_763 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "qualified")- )}--happyReduce_764 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_764 = happySpecReduce_1 283# happyReduction_764-happyReduction_764 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "hiding")- )}--happyReduce_765 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_765 = happySpecReduce_1 283# happyReduction_765-happyReduction_765 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "export")- )}--happyReduce_766 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_766 = happySpecReduce_1 283# happyReduction_766-happyReduction_766 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "label")- )}--happyReduce_767 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_767 = happySpecReduce_1 283# happyReduction_767-happyReduction_767 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "dynamic")- )}--happyReduce_768 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_768 = happySpecReduce_1 283# happyReduction_768-happyReduction_768 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "stdcall")- )}--happyReduce_769 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_769 = happySpecReduce_1 283# happyReduction_769-happyReduction_769 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "ccall")- )}--happyReduce_770 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_770 = happySpecReduce_1 283# happyReduction_770-happyReduction_770 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "capi")- )}--happyReduce_771 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_771 = happySpecReduce_1 283# happyReduction_771-happyReduction_771 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "prim")- )}--happyReduce_772 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_772 = happySpecReduce_1 283# happyReduction_772-happyReduction_772 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "javascript")- )}--happyReduce_773 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_773 = happySpecReduce_1 283# happyReduction_773-happyReduction_773 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "group")- )}--happyReduce_774 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_774 = happySpecReduce_1 283# happyReduction_774-happyReduction_774 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "stock")- )}--happyReduce_775 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_775 = happySpecReduce_1 283# happyReduction_775-happyReduction_775 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "anyclass")- )}--happyReduce_776 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_776 = happySpecReduce_1 283# happyReduction_776-happyReduction_776 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "unit")- )}--happyReduce_777 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_777 = happySpecReduce_1 283# happyReduction_777-happyReduction_777 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "dependency")- )}--happyReduce_778 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_778 = happySpecReduce_1 283# happyReduction_778-happyReduction_778 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn299- (sL1 happy_var_1 (fsLit "signature")- )}--happyReduce_779 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_779 = happyMonadReduce 1# 284# happyReduction_779-happyReduction_779 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( ams (sL1 happy_var_1 (fsLit "!")) [mj AnnBang happy_var_1])})- ) (\r -> happyReturn (happyIn300 r))--happyReduce_780 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_780 = happySpecReduce_1 284# happyReduction_780-happyReduction_780 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn300- (sL1 happy_var_1 (fsLit ".")- )}--happyReduce_781 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_781 = happySpecReduce_1 285# happyReduction_781-happyReduction_781 happy_x_1- = case happyOut302 happy_x_1 of { happy_var_1 -> - happyIn301- (happy_var_1- )}--happyReduce_782 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_782 = happySpecReduce_1 285# happyReduction_782-happyReduction_782 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn301- (sL1 happy_var_1 $! mkQual dataName (getQCONID happy_var_1)- )}--happyReduce_783 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_783 = happySpecReduce_1 286# happyReduction_783-happyReduction_783 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn302- (sL1 happy_var_1 $ mkUnqual dataName (getCONID happy_var_1)- )}--happyReduce_784 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_784 = happySpecReduce_1 287# happyReduction_784-happyReduction_784 happy_x_1- = case happyOut304 happy_x_1 of { happy_var_1 -> - happyIn303- (happy_var_1- )}--happyReduce_785 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_785 = happySpecReduce_1 287# happyReduction_785-happyReduction_785 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1 happy_var_1 $ mkQual dataName (getQCONSYM happy_var_1)- )}--happyReduce_786 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_786 = happySpecReduce_1 288# happyReduction_786-happyReduction_786 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn304- (sL1 happy_var_1 $ mkUnqual dataName (getCONSYM happy_var_1)- )}--happyReduce_787 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_787 = happySpecReduce_1 288# happyReduction_787-happyReduction_787 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn304- (sL1 happy_var_1 $ consDataCon_RDR- )}--happyReduce_788 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_788 = happySpecReduce_1 289# happyReduction_788-happyReduction_788 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsChar (getCHARs happy_var_1) $ getCHAR happy_var_1- )}--happyReduce_789 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_789 = happySpecReduce_1 289# happyReduction_789-happyReduction_789 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsString (getSTRINGs happy_var_1)- $ getSTRING happy_var_1- )}--happyReduce_790 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_790 = happySpecReduce_1 289# happyReduction_790-happyReduction_790 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsIntPrim (getPRIMINTEGERs happy_var_1)- $ getPRIMINTEGER happy_var_1- )}--happyReduce_791 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_791 = happySpecReduce_1 289# happyReduction_791-happyReduction_791 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsWordPrim (getPRIMWORDs happy_var_1)- $ getPRIMWORD happy_var_1- )}--happyReduce_792 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_792 = happySpecReduce_1 289# happyReduction_792-happyReduction_792 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsCharPrim (getPRIMCHARs happy_var_1)- $ getPRIMCHAR happy_var_1- )}--happyReduce_793 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_793 = happySpecReduce_1 289# happyReduction_793-happyReduction_793 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsStringPrim (getPRIMSTRINGs happy_var_1)- $ getPRIMSTRING happy_var_1- )}--happyReduce_794 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_794 = happySpecReduce_1 289# happyReduction_794-happyReduction_794 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsFloatPrim $ getPRIMFLOAT happy_var_1- )}--happyReduce_795 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_795 = happySpecReduce_1 289# happyReduction_795-happyReduction_795 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn305- (sL1 happy_var_1 $ HsDoublePrim $ getPRIMDOUBLE happy_var_1- )}--happyReduce_796 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_796 = happySpecReduce_1 290# happyReduction_796-happyReduction_796 happy_x_1- = happyIn306- (()- )--happyReduce_797 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_797 = happyMonadReduce 1# 290# happyReduction_797-happyReduction_797 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((( popContext))- ) (\r -> happyReturn (happyIn306 r))--happyReduce_798 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_798 = happySpecReduce_1 291# happyReduction_798-happyReduction_798 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn307- (sL1 happy_var_1 $ mkModuleNameFS (getCONID happy_var_1)- )}--happyReduce_799 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_799 = happySpecReduce_1 291# happyReduction_799-happyReduction_799 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn307- (sL1 happy_var_1 $ let (mod,c) = getQCONID happy_var_1 in- mkModuleNameFS- (mkFastString- (unpackFS mod ++ '.':unpackFS c))- )}--happyReduce_800 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_800 = happySpecReduce_2 292# happyReduction_800-happyReduction_800 happy_x_2- happy_x_1- = case happyOut308 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn308- (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)- )}}--happyReduce_801 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_801 = happySpecReduce_1 292# happyReduction_801-happyReduction_801 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn308- (([gl happy_var_1],1)- )}--happyReduce_802 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_802 = happySpecReduce_1 293# happyReduction_802-happyReduction_802 happy_x_1- = case happyOut310 happy_x_1 of { happy_var_1 -> - happyIn309- (happy_var_1- )}--happyReduce_803 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_803 = happySpecReduce_0 293# happyReduction_803-happyReduction_803 = happyIn309- (([], 0)- )--happyReduce_804 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_804 = happySpecReduce_2 294# happyReduction_804-happyReduction_804 happy_x_2- happy_x_1- = case happyOut310 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn310- (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)- )}}--happyReduce_805 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_805 = happySpecReduce_1 294# happyReduction_805-happyReduction_805 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn310- (([gl happy_var_1],1)- )}--happyReduce_806 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_806 = happyMonadReduce 1# 295# happyReduction_806-happyReduction_806 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( return (sL1 happy_var_1 (HsDocString (mkFastString (getDOCNEXT happy_var_1)))))})- ) (\r -> happyReturn (happyIn311 r))--happyReduce_807 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_807 = happyMonadReduce 1# 296# happyReduction_807-happyReduction_807 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( return (sL1 happy_var_1 (HsDocString (mkFastString (getDOCPREV happy_var_1)))))})- ) (\r -> happyReturn (happyIn312 r))--happyReduce_808 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_808 = happyMonadReduce 1# 297# happyReduction_808-happyReduction_808 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - (- let string = getDOCNAMED happy_var_1- (name, rest) = break isSpace string- in return (sL1 happy_var_1 (name, HsDocString (mkFastString rest))))})- ) (\r -> happyReturn (happyIn313 r))--happyReduce_809 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_809 = happyMonadReduce 1# 298# happyReduction_809-happyReduction_809 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( let (n, doc) = getDOCSECTION happy_var_1 in- return (sL1 happy_var_1 (n, HsDocString (mkFastString doc))))})- ) (\r -> happyReturn (happyIn314 r))--happyReduce_810 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_810 = happyMonadReduce 1# 299# happyReduction_810-happyReduction_810 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( let string = getDOCNEXT happy_var_1 in- return (Just (sL1 happy_var_1 (HsDocString (mkFastString string)))))})- ) (\r -> happyReturn (happyIn315 r))--happyReduce_811 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_811 = happySpecReduce_1 300# happyReduction_811-happyReduction_811 happy_x_1- = case happyOut312 happy_x_1 of { happy_var_1 -> - happyIn316- (Just happy_var_1- )}--happyReduce_812 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_812 = happySpecReduce_0 300# happyReduction_812-happyReduction_812 = happyIn316- (Nothing- )--happyReduce_813 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_813 = happySpecReduce_1 301# happyReduction_813-happyReduction_813 happy_x_1- = case happyOut311 happy_x_1 of { happy_var_1 -> - happyIn317- (Just happy_var_1- )}--happyReduce_814 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_814 = happySpecReduce_0 301# happyReduction_814-happyReduction_814 = happyIn317- (Nothing- )--happyNewToken action sts stk- = (lexer True)(\tk -> - let cont i = happyDoAction i tk action sts stk in- case tk of {- L _ ITeof -> happyDoAction 155# tk action sts stk;- L _ ITunderscore -> cont 1#;- L _ ITas -> cont 2#;- L _ ITcase -> cont 3#;- L _ ITclass -> cont 4#;- L _ ITdata -> cont 5#;- L _ ITdefault -> cont 6#;- L _ ITderiving -> cont 7#;- L _ ITdo -> cont 8#;- L _ ITelse -> cont 9#;- L _ IThiding -> cont 10#;- L _ ITif -> cont 11#;- L _ ITimport -> cont 12#;- L _ ITin -> cont 13#;- L _ ITinfix -> cont 14#;- L _ ITinfixl -> cont 15#;- L _ ITinfixr -> cont 16#;- L _ ITinstance -> cont 17#;- L _ ITlet -> cont 18#;- L _ ITmodule -> cont 19#;- L _ ITnewtype -> cont 20#;- L _ ITof -> cont 21#;- L _ ITqualified -> cont 22#;- L _ ITthen -> cont 23#;- L _ ITtype -> cont 24#;- L _ ITwhere -> cont 25#;- L _ (ITforall _) -> cont 26#;- L _ ITforeign -> cont 27#;- L _ ITexport -> cont 28#;- L _ ITlabel -> cont 29#;- L _ ITdynamic -> cont 30#;- L _ ITsafe -> cont 31#;- L _ ITinterruptible -> cont 32#;- L _ ITunsafe -> cont 33#;- L _ ITmdo -> cont 34#;- L _ ITfamily -> cont 35#;- L _ ITrole -> cont 36#;- L _ ITstdcallconv -> cont 37#;- L _ ITccallconv -> cont 38#;- L _ ITcapiconv -> cont 39#;- L _ ITprimcallconv -> cont 40#;- L _ ITjavascriptcallconv -> cont 41#;- L _ ITproc -> cont 42#;- L _ ITrec -> cont 43#;- L _ ITgroup -> cont 44#;- L _ ITby -> cont 45#;- L _ ITusing -> cont 46#;- L _ ITpattern -> cont 47#;- L _ ITstatic -> cont 48#;- L _ ITstock -> cont 49#;- L _ ITanyclass -> cont 50#;- L _ ITunit -> cont 51#;- L _ ITsignature -> cont 52#;- L _ ITdependency -> cont 53#;- L _ (ITinline_prag _ _ _) -> cont 54#;- L _ (ITspec_prag _) -> cont 55#;- L _ (ITspec_inline_prag _ _) -> cont 56#;- L _ (ITsource_prag _) -> cont 57#;- L _ (ITrules_prag _) -> cont 58#;- L _ (ITcore_prag _) -> cont 59#;- L _ (ITscc_prag _) -> cont 60#;- L _ (ITgenerated_prag _) -> cont 61#;- L _ (ITdeprecated_prag _) -> cont 62#;- L _ (ITwarning_prag _) -> cont 63#;- L _ (ITunpack_prag _) -> cont 64#;- L _ (ITnounpack_prag _) -> cont 65#;- L _ (ITann_prag _) -> cont 66#;- L _ (ITvect_prag _) -> cont 67#;- L _ (ITvect_scalar_prag _) -> cont 68#;- L _ (ITnovect_prag _) -> cont 69#;- L _ (ITminimal_prag _) -> cont 70#;- L _ (ITctype _) -> cont 71#;- L _ (IToverlapping_prag _) -> cont 72#;- L _ (IToverlappable_prag _) -> cont 73#;- L _ (IToverlaps_prag _) -> cont 74#;- L _ (ITincoherent_prag _) -> cont 75#;- L _ (ITcomplete_prag _) -> cont 76#;- L _ ITclose_prag -> cont 77#;- L _ ITdotdot -> cont 78#;- L _ ITcolon -> cont 79#;- L _ (ITdcolon _) -> cont 80#;- L _ ITequal -> cont 81#;- L _ ITlam -> cont 82#;- L _ ITlcase -> cont 83#;- L _ ITvbar -> cont 84#;- L _ (ITlarrow _) -> cont 85#;- L _ (ITrarrow _) -> cont 86#;- L _ ITat -> cont 87#;- L _ ITtilde -> cont 88#;- L _ ITtildehsh -> cont 89#;- L _ (ITdarrow _) -> cont 90#;- L _ ITminus -> cont 91#;- L _ ITbang -> cont 92#;- L _ (ITlarrowtail _) -> cont 93#;- L _ (ITrarrowtail _) -> cont 94#;- L _ (ITLarrowtail _) -> cont 95#;- L _ (ITRarrowtail _) -> cont 96#;- L _ ITdot -> cont 97#;- L _ ITtypeApp -> cont 98#;- L _ ITocurly -> cont 99#;- L _ ITccurly -> cont 100#;- L _ ITvocurly -> cont 101#;- L _ ITvccurly -> cont 102#;- L _ ITobrack -> cont 103#;- L _ ITcbrack -> cont 104#;- L _ ITopabrack -> cont 105#;- L _ ITcpabrack -> cont 106#;- L _ IToparen -> cont 107#;- L _ ITcparen -> cont 108#;- L _ IToubxparen -> cont 109#;- L _ ITcubxparen -> cont 110#;- L _ (IToparenbar _) -> cont 111#;- L _ (ITcparenbar _) -> cont 112#;- L _ ITsemi -> cont 113#;- L _ ITcomma -> cont 114#;- L _ ITbackquote -> cont 115#;- L _ ITsimpleQuote -> cont 116#;- L _ (ITvarid _) -> cont 117#;- L _ (ITconid _) -> cont 118#;- L _ (ITvarsym _) -> cont 119#;- L _ (ITconsym _) -> cont 120#;- L _ (ITqvarid _) -> cont 121#;- L _ (ITqconid _) -> cont 122#;- L _ (ITqvarsym _) -> cont 123#;- L _ (ITqconsym _) -> cont 124#;- L _ (ITdupipvarid _) -> cont 125#;- L _ (ITlabelvarid _) -> cont 126#;- L _ (ITchar _ _) -> cont 127#;- L _ (ITstring _ _) -> cont 128#;- L _ (ITinteger _ _) -> cont 129#;- L _ (ITrational _) -> cont 130#;- L _ (ITprimchar _ _) -> cont 131#;- L _ (ITprimstring _ _) -> cont 132#;- L _ (ITprimint _ _) -> cont 133#;- L _ (ITprimword _ _) -> cont 134#;- L _ (ITprimfloat _) -> cont 135#;- L _ (ITprimdouble _) -> cont 136#;- L _ (ITdocCommentNext _) -> cont 137#;- L _ (ITdocCommentPrev _) -> cont 138#;- L _ (ITdocCommentNamed _) -> cont 139#;- L _ (ITdocSection _ _) -> cont 140#;- L _ (ITopenExpQuote _ _) -> cont 141#;- L _ ITopenPatQuote -> cont 142#;- L _ ITopenTypQuote -> cont 143#;- L _ ITopenDecQuote -> cont 144#;- L _ (ITcloseQuote _) -> cont 145#;- L _ (ITopenTExpQuote _) -> cont 146#;- L _ ITcloseTExpQuote -> cont 147#;- L _ (ITidEscape _) -> cont 148#;- L _ ITparenEscape -> cont 149#;- L _ (ITidTyEscape _) -> cont 150#;- L _ ITparenTyEscape -> cont 151#;- L _ ITtyQuote -> cont 152#;- L _ (ITquasiQuote _) -> cont 153#;- L _ (ITqQuasiQuote _) -> cont 154#;- _ -> happyError' (tk, [])- })--happyError_ explist 155# tk = happyError' (tk, explist)-happyError_ explist _ tk = happyError' (tk, explist)--happyThen :: () => P a -> (a -> P b) -> P b-happyThen = (>>=)-happyReturn :: () => a -> P a-happyReturn = (return)-happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn )--happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )--happyDoAction :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )--happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn ))--happyThen1 :: () => P a -> (a -> P b) -> P b-happyThen1 = happyThen-happyReturn1 :: () => a -> P a-happyReturn1 = happyReturn-happyError' :: () => (((Located Token)), [String]) -> P a-happyError' tk = (\(tokens, explist) -> happyError) tk-parseModule = happySomeParser where- happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut34 x))--parseSignature = happySomeParser where- happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut33 x))--parseImport = happySomeParser where- happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut64 x))--parseStatement = happySomeParser where- happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut246 x))--parseDeclaration = happySomeParser where- happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut77 x))--parseExpression = happySomeParser where- happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut200 x))--parsePattern = happySomeParser where- happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (happyOut239 x))--parseTypeSignature = happySomeParser where- happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (happyOut196 x))--parseStmt = happySomeParser where- happySomeParser = happyThen (happyParse 8#) (\x -> happyReturn (happyOut245 x))--parseIdentifier = happySomeParser where- happySomeParser = happyThen (happyParse 9#) (\x -> happyReturn (happyOut16 x))--parseType = happySomeParser where- happySomeParser = happyThen (happyParse 10#) (\x -> happyReturn (happyOut151 x))--parseBackpack = happySomeParser where- happySomeParser = happyThen (happyParse 11#) (\x -> happyReturn (happyOut17 x))--parseHeader = happySomeParser where- happySomeParser = happyThen (happyParse 12#) (\x -> happyReturn (happyOut43 x))--happySeq = happyDontSeq---happyError :: P a-happyError = srcParseFail--getVARID (L _ (ITvarid x)) = x-getCONID (L _ (ITconid x)) = x-getVARSYM (L _ (ITvarsym x)) = x-getCONSYM (L _ (ITconsym x)) = x-getQVARID (L _ (ITqvarid x)) = x-getQCONID (L _ (ITqconid x)) = x-getQVARSYM (L _ (ITqvarsym x)) = x-getQCONSYM (L _ (ITqconsym x)) = x-getIPDUPVARID (L _ (ITdupipvarid x)) = x-getLABELVARID (L _ (ITlabelvarid x)) = x-getCHAR (L _ (ITchar _ x)) = x-getSTRING (L _ (ITstring _ x)) = x-getINTEGER (L _ (ITinteger _ x)) = x-getRATIONAL (L _ (ITrational x)) = x-getPRIMCHAR (L _ (ITprimchar _ x)) = x-getPRIMSTRING (L _ (ITprimstring _ x)) = x-getPRIMINTEGER (L _ (ITprimint _ x)) = x-getPRIMWORD (L _ (ITprimword _ x)) = x-getPRIMFLOAT (L _ (ITprimfloat x)) = x-getPRIMDOUBLE (L _ (ITprimdouble x)) = x-getTH_ID_SPLICE (L _ (ITidEscape x)) = x-getTH_ID_TY_SPLICE (L _ (ITidTyEscape x)) = x-getINLINE (L _ (ITinline_prag _ inl conl)) = (inl,conl)-getSPEC_INLINE (L _ (ITspec_inline_prag _ True)) = (Inline, FunLike)-getSPEC_INLINE (L _ (ITspec_inline_prag _ False)) = (NoInline,FunLike)-getCOMPLETE_PRAGs (L _ (ITcomplete_prag x)) = x--getDOCNEXT (L _ (ITdocCommentNext x)) = x-getDOCPREV (L _ (ITdocCommentPrev x)) = x-getDOCNAMED (L _ (ITdocCommentNamed x)) = x-getDOCSECTION (L _ (ITdocSection n x)) = (n, x)--getCHARs (L _ (ITchar src _)) = src-getSTRINGs (L _ (ITstring src _)) = src-getINTEGERs (L _ (ITinteger src _)) = src-getPRIMCHARs (L _ (ITprimchar src _)) = src-getPRIMSTRINGs (L _ (ITprimstring src _)) = src-getPRIMINTEGERs (L _ (ITprimint src _)) = src-getPRIMWORDs (L _ (ITprimword src _)) = src---- See Note [Pragma source text] in BasicTypes for the following-getINLINE_PRAGs (L _ (ITinline_prag src _ _)) = src-getSPEC_PRAGs (L _ (ITspec_prag src)) = src-getSPEC_INLINE_PRAGs (L _ (ITspec_inline_prag src _)) = src-getSOURCE_PRAGs (L _ (ITsource_prag src)) = src-getRULES_PRAGs (L _ (ITrules_prag src)) = src-getWARNING_PRAGs (L _ (ITwarning_prag src)) = src-getDEPRECATED_PRAGs (L _ (ITdeprecated_prag src)) = src-getSCC_PRAGs (L _ (ITscc_prag src)) = src-getGENERATED_PRAGs (L _ (ITgenerated_prag src)) = src-getCORE_PRAGs (L _ (ITcore_prag src)) = src-getUNPACK_PRAGs (L _ (ITunpack_prag src)) = src-getNOUNPACK_PRAGs (L _ (ITnounpack_prag src)) = src-getANN_PRAGs (L _ (ITann_prag src)) = src-getVECT_PRAGs (L _ (ITvect_prag src)) = src-getVECT_SCALAR_PRAGs (L _ (ITvect_scalar_prag src)) = src-getNOVECT_PRAGs (L _ (ITnovect_prag src)) = src-getMINIMAL_PRAGs (L _ (ITminimal_prag src)) = src-getOVERLAPPABLE_PRAGs (L _ (IToverlappable_prag src)) = src-getOVERLAPPING_PRAGs (L _ (IToverlapping_prag src)) = src-getOVERLAPS_PRAGs (L _ (IToverlaps_prag src)) = src-getINCOHERENT_PRAGs (L _ (ITincoherent_prag src)) = src-getCTYPEs (L _ (ITctype src)) = src--getStringLiteral l = StringLiteral (getSTRINGs l) (getSTRING l)--isUnicode :: Located Token -> Bool-isUnicode (L _ (ITforall iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITdarrow iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITdcolon iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITlarrow iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITrarrow iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITlarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITrarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITLarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITRarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (IToparenbar iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITcparenbar iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITopenExpQuote _ iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITcloseQuote iu)) = iu == UnicodeSyntax-isUnicode _ = False--hasE :: Located Token -> Bool-hasE (L _ (ITopenExpQuote HasE _)) = True-hasE (L _ (ITopenTExpQuote HasE)) = True-hasE _ = False--getSCC :: Located Token -> P FastString-getSCC lt = do let s = getSTRING lt- err = "Spaces are not allowed in SCCs"- -- We probably actually want to be more restrictive than this- if ' ' `elem` unpackFS s- then failSpanMsgP (getLoc lt) (text err)- else return s---- Utilities for combining source spans-comb2 :: Located a -> Located b -> SrcSpan-comb2 a b = a `seq` b `seq` combineLocs a b--comb3 :: Located a -> Located b -> Located c -> SrcSpan-comb3 a b c = a `seq` b `seq` c `seq`- combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLoc c))--comb4 :: Located a -> Located b -> Located c -> Located d -> SrcSpan-comb4 a b c d = a `seq` b `seq` c `seq` d `seq`- (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $- combineSrcSpans (getLoc c) (getLoc d))---- strict constructor version:-{-# INLINE sL #-}-sL :: SrcSpan -> a -> Located a-sL span a = span `seq` a `seq` L span a---- See Note [Adding location info] for how these utility functions are used---- replaced last 3 CPP macros in this file-{-# INLINE sL0 #-}-sL0 :: a -> Located a-sL0 = L noSrcSpan -- #define L0 L noSrcSpan--{-# INLINE sL1 #-}-sL1 :: Located a -> b -> Located b-sL1 x = sL (getLoc x) -- #define sL1 sL (getLoc $1)--{-# INLINE sLL #-}-sLL :: Located a -> Located b -> c -> Located c-sLL x y = sL (comb2 x y) -- #define LL sL (comb2 $1 $>)--{- Note [Adding location info]- ~~~~~~~~~~~~~~~~~~~~~~~~~~~--This is done using the three functions below, sL0, sL1-and sLL. Note that these functions were mechanically-converted from the three macros that used to exist before,-namely L0, L1 and LL.--They each add a SrcSpan to their argument.-- sL0 adds 'noSrcSpan', used for empty productions- -- This doesn't seem to work anymore -=chak-- sL1 for a production with a single token on the lhs. Grabs the SrcSpan- from that token.-- sLL for a production with >1 token on the lhs. Makes up a SrcSpan from- the first and last tokens.--These suffice for the majority of cases. However, we must be-especially careful with empty productions: sLL won't work if the first-or last token on the lhs can represent an empty span. In these cases,-we have to calculate the span using more of the tokens from the lhs, eg.-- | 'newtype' tycl_hdr '=' newconstr deriving- { L (comb3 $1 $4 $5)- (mkTyData NewType (unLoc $2) $4 (unLoc $5)) }--We provide comb3 and comb4 functions which are useful in such cases.--Be careful: there's no checking that you actually got this right, the-only symptom will be that the SrcSpans of your syntax will be-incorrect.---}---- Make a source location for the file. We're a bit lazy here and just--- make a point SrcSpan at line 1, column 0. Strictly speaking we should--- try to find the span of the whole file (ToDo).-fileSrcSpan :: P SrcSpan-fileSrcSpan = do- l <- getSrcLoc;- let loc = mkSrcLoc (srcLocFile l) 1 1;- return (mkSrcSpan loc loc)---- Hint about the MultiWayIf extension-hintMultiWayIf :: SrcSpan -> P ()-hintMultiWayIf span = do- mwiEnabled <- liftM ((LangExt.MultiWayIf `extopt`) . options) getPState- unless mwiEnabled $ parseErrorSDoc span $- text "Multi-way if-expressions need MultiWayIf turned on"---- Hint about if usage for beginners-hintIf :: SrcSpan -> String -> P (LHsExpr RdrName)-hintIf span msg = do- mwiEnabled <- liftM ((LangExt.MultiWayIf `extopt`) . options) getPState- if mwiEnabled- then parseErrorSDoc span $ text $ "parse error in if statement"- else parseErrorSDoc span $ text $ "parse error in if statement: "++msg---- Hint about explicit-forall, assuming UnicodeSyntax is on-hintExplicitForall :: SrcSpan -> P ()-hintExplicitForall span = do- forall <- extension explicitForallEnabled- rulePrag <- extension inRulePrag- unless (forall || rulePrag) $ parseErrorSDoc span $ vcat- [ text "Illegal symbol '\x2200' in type" -- U+2200 FOR ALL- , text "Perhaps you intended to use RankNTypes or a similar language"- , text "extension to enable explicit-forall syntax: \x2200 <tvs>. <type>"- ]---- Hint about explicit-forall, assuming UnicodeSyntax is off-hintExplicitForall' :: SrcSpan -> P (GenLocated SrcSpan RdrName)-hintExplicitForall' span = do- forall <- extension explicitForallEnabled- let illegalDot = "Illegal symbol '.' in type"- if forall- then parseErrorSDoc span $ vcat- [ text illegalDot- , text "Perhaps you meant to write 'forall <tvs>. <type>'?"- ]- else parseErrorSDoc span $ vcat- [ text illegalDot- , text "Perhaps you intended to use RankNTypes or a similar language"- , text "extension to enable explicit-forall syntax: forall <tvs>. <type>"- ]--{--%************************************************************************-%* *- Helper functions for generating annotations in the parser-%* *-%************************************************************************--For the general principles of the following routines, see Note [Api annotations]-in ApiAnnotation.hs---}---- |Construct an AddAnn from the annotation keyword and the location--- of the keyword itself-mj :: AnnKeywordId -> Located e -> AddAnn-mj a l s = addAnnotation s a (gl l)---- |Construct an AddAnn from the annotation keyword and the Located Token. If--- the token has a unicode equivalent and this has been used, provide the--- unicode variant of the annotation.-mu :: AnnKeywordId -> Located Token -> AddAnn-mu a lt@(L l t) = (\s -> addAnnotation s (toUnicodeAnn a lt) l)---- | If the 'Token' is using its unicode variant return the unicode variant of--- the annotation-toUnicodeAnn :: AnnKeywordId -> Located Token -> AnnKeywordId-toUnicodeAnn a t = if isUnicode t then unicodeAnn a else a--gl = getLoc---- |Add an annotation to the located element, and return the located--- element as a pass through-aa :: Located a -> (AnnKeywordId,Located c) -> P (Located a)-aa a@(L l _) (b,s) = addAnnotation l b (gl s) >> return a---- |Add an annotation to a located element resulting from a monadic action-am :: P (Located a) -> (AnnKeywordId, Located b) -> P (Located a)-am a (b,s) = do- av@(L l _) <- a- addAnnotation l b (gl s)- return av---- | Add a list of AddAnns to the given AST element. For example,--- the parsing rule for @let@ looks like:------ @--- | 'let' binds 'in' exp {% ams (sLL $1 $> $ HsLet (snd $ unLoc $2) $4)--- (mj AnnLet $1:mj AnnIn $3--- :(fst $ unLoc $2)) }--- @------ This adds an AnnLet annotation for @let@, an AnnIn for @in@, as well--- as any annotations that may arise in the binds. This will include open--- and closing braces if they are used to delimit the let expressions.----ams :: Located a -> [AddAnn] -> P (Located a)-ams a@(L l _) bs = addAnnsAt l bs >> return a---- |Add all [AddAnn] to an AST element wrapped in a Just-aljs :: Located (Maybe a) -> [AddAnn] -> P (Located (Maybe a))-aljs a@(L l _) bs = addAnnsAt l bs >> return a---- |Add all [AddAnn] to an AST element wrapped in a Just-ajs a@(Just (L l _)) bs = addAnnsAt l bs >> return a---- |Add a list of AddAnns to the given AST element, where the AST element is the--- result of a monadic action-amms :: P (Located a) -> [AddAnn] -> P (Located a)-amms a bs = do { av@(L l _) <- a- ; addAnnsAt l bs- ; return av }---- |Add a list of AddAnns to the AST element, and return the element as a--- OrdList-amsu :: Located a -> [AddAnn] -> P (OrdList (Located a))-amsu a@(L l _) bs = addAnnsAt l bs >> return (unitOL a)---- |Synonyms for AddAnn versions of AnnOpen and AnnClose-mo,mc :: Located Token -> AddAnn-mo ll = mj AnnOpen ll-mc ll = mj AnnClose ll--moc,mcc :: Located Token -> AddAnn-moc ll = mj AnnOpenC ll-mcc ll = mj AnnCloseC ll--mop,mcp :: Located Token -> AddAnn-mop ll = mj AnnOpenP ll-mcp ll = mj AnnCloseP ll--mos,mcs :: Located Token -> AddAnn-mos ll = mj AnnOpenS ll-mcs ll = mj AnnCloseS ll---- |Given a list of the locations of commas, provide a [AddAnn] with an AnnComma--- entry for each SrcSpan-mcommas :: [SrcSpan] -> [AddAnn]-mcommas ss = map (\s -> mj AnnCommaTuple (L s ())) ss---- |Given a list of the locations of '|'s, provide a [AddAnn] with an AnnVbar--- entry for each SrcSpan-mvbars :: [SrcSpan] -> [AddAnn]-mvbars ss = map (\s -> mj AnnVbar (L s ())) ss---- |Get the location of the last element of a OrdList, or noSrcSpan-oll :: OrdList (Located a) -> SrcSpan-oll l =- if isNilOL l then noSrcSpan- else getLoc (lastOL l)---- |Add a semicolon annotation in the right place in a list. If the--- leading list is empty, add it to the tail-asl :: [Located a] -> Located b -> Located a -> P()-asl [] (L ls _) (L l _) = addAnnotation l AnnSemi ls-asl (x:_xs) (L ls _) _x = addAnnotation (getLoc x) AnnSemi ls+import GhcPrelude++import qualified GHC.LanguageExtensions as LangExt+import qualified Data.Array as Happy_Data_Array+import qualified Data.Bits as Bits+import qualified GHC.Exts as Happy_GHC_Exts+import Control.Applicative(Applicative(..))+import Control.Monad (ap)++-- parser produced by Happy Version 1.19.9++newtype HappyAbsSyn = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = Happy_GHC_Exts.Any+#else+type HappyAny = forall a . a+#endif+happyIn16 :: (Located RdrName) -> (HappyAbsSyn )+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut16 #-}+happyIn17 :: ([LHsUnit PackageName]) -> (HappyAbsSyn )+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn ) -> ([LHsUnit PackageName])+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut17 #-}+happyIn18 :: (OrdList (LHsUnit PackageName)) -> (HappyAbsSyn )+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn ) -> (OrdList (LHsUnit PackageName))+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut18 #-}+happyIn19 :: (LHsUnit PackageName) -> (HappyAbsSyn )+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn ) -> (LHsUnit PackageName)+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut19 #-}+happyIn20 :: (LHsUnitId PackageName) -> (HappyAbsSyn )+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn ) -> (LHsUnitId PackageName)+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut20 #-}+happyIn21 :: (OrdList (LHsModuleSubst PackageName)) -> (HappyAbsSyn )+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn ) -> (OrdList (LHsModuleSubst PackageName))+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut21 #-}+happyIn22 :: (LHsModuleSubst PackageName) -> (HappyAbsSyn )+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn ) -> (LHsModuleSubst PackageName)+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut22 #-}+happyIn23 :: (LHsModuleId PackageName) -> (HappyAbsSyn )+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn ) -> (LHsModuleId PackageName)+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut23 #-}+happyIn24 :: (Located PackageName) -> (HappyAbsSyn )+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn ) -> (Located PackageName)+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut24 #-}+happyIn25 :: (Located FastString) -> (HappyAbsSyn )+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn ) -> (Located FastString)+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut25 #-}+happyIn26 :: (Located FastString) -> (HappyAbsSyn )+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn ) -> (Located FastString)+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut26 #-}+happyIn27 :: (Maybe [LRenaming]) -> (HappyAbsSyn )+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn27 #-}+happyOut27 :: (HappyAbsSyn ) -> (Maybe [LRenaming])+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut27 #-}+happyIn28 :: (OrdList LRenaming) -> (HappyAbsSyn )+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn28 #-}+happyOut28 :: (HappyAbsSyn ) -> (OrdList LRenaming)+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut28 #-}+happyIn29 :: (LRenaming) -> (HappyAbsSyn )+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn29 #-}+happyOut29 :: (HappyAbsSyn ) -> (LRenaming)+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut29 #-}+happyIn30 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn30 #-}+happyOut30 :: (HappyAbsSyn ) -> (OrdList (LHsUnitDecl PackageName))+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut30 #-}+happyIn31 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn31 #-}+happyOut31 :: (HappyAbsSyn ) -> (OrdList (LHsUnitDecl PackageName))+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut31 #-}+happyIn32 :: (LHsUnitDecl PackageName) -> (HappyAbsSyn )+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn32 #-}+happyOut32 :: (HappyAbsSyn ) -> (LHsUnitDecl PackageName)+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut32 #-}+happyIn33 :: (Located (HsModule GhcPs)) -> (HappyAbsSyn )+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn33 #-}+happyOut33 :: (HappyAbsSyn ) -> (Located (HsModule GhcPs))+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut33 #-}+happyIn34 :: (Located (HsModule GhcPs)) -> (HappyAbsSyn )+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn34 #-}+happyOut34 :: (HappyAbsSyn ) -> (Located (HsModule GhcPs))+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut34 #-}+happyIn35 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn35 #-}+happyOut35 :: (HappyAbsSyn ) -> (Maybe LHsDocString)+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut35 #-}+happyIn36 :: (()) -> (HappyAbsSyn )+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn36 #-}+happyOut36 :: (HappyAbsSyn ) -> (())+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut36 #-}+happyIn37 :: (()) -> (HappyAbsSyn )+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn37 #-}+happyOut37 :: (HappyAbsSyn ) -> (())+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut37 #-}+happyIn38 :: (Maybe (Located WarningTxt)) -> (HappyAbsSyn )+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn38 #-}+happyOut38 :: (HappyAbsSyn ) -> (Maybe (Located WarningTxt))+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut38 #-}+happyIn39 :: (([AddAnn]+ ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn39 #-}+happyOut39 :: (HappyAbsSyn ) -> (([AddAnn]+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])))+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut39 #-}+happyIn40 :: (([AddAnn]+ ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn40 #-}+happyOut40 :: (HappyAbsSyn ) -> (([AddAnn]+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])))+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut40 #-}+happyIn41 :: (([AddAnn]+ ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn41 #-}+happyOut41 :: (HappyAbsSyn ) -> (([AddAnn]+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])))+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut41 #-}+happyIn42 :: (([LImportDecl GhcPs], [LHsDecl GhcPs])) -> (HappyAbsSyn )+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn42 #-}+happyOut42 :: (HappyAbsSyn ) -> (([LImportDecl GhcPs], [LHsDecl GhcPs]))+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut42 #-}+happyIn43 :: (Located (HsModule GhcPs)) -> (HappyAbsSyn )+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn43 #-}+happyOut43 :: (HappyAbsSyn ) -> (Located (HsModule GhcPs))+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut43 #-}+happyIn44 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn44 #-}+happyOut44 :: (HappyAbsSyn ) -> ([LImportDecl GhcPs])+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut44 #-}+happyIn45 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn45 #-}+happyOut45 :: (HappyAbsSyn ) -> ([LImportDecl GhcPs])+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut45 #-}+happyIn46 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn46 #-}+happyOut46 :: (HappyAbsSyn ) -> ([LImportDecl GhcPs])+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut46 #-}+happyIn47 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn47 #-}+happyOut47 :: (HappyAbsSyn ) -> ([LImportDecl GhcPs])+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut47 #-}+happyIn48 :: ((Maybe (Located [LIE GhcPs]))) -> (HappyAbsSyn )+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn48 #-}+happyOut48 :: (HappyAbsSyn ) -> ((Maybe (Located [LIE GhcPs])))+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut48 #-}+happyIn49 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn49 #-}+happyOut49 :: (HappyAbsSyn ) -> (OrdList (LIE GhcPs))+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut49 #-}+happyIn50 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn50 #-}+happyOut50 :: (HappyAbsSyn ) -> (OrdList (LIE GhcPs))+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut50 #-}+happyIn51 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn51 #-}+happyOut51 :: (HappyAbsSyn ) -> (OrdList (LIE GhcPs))+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut51 #-}+happyIn52 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn52 #-}+happyOut52 :: (HappyAbsSyn ) -> (OrdList (LIE GhcPs))+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut52 #-}+happyIn53 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn53 #-}+happyOut53 :: (HappyAbsSyn ) -> (OrdList (LIE GhcPs))+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut53 #-}+happyIn54 :: (Located ([AddAnn],ImpExpSubSpec)) -> (HappyAbsSyn )+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn54 #-}+happyOut54 :: (HappyAbsSyn ) -> (Located ([AddAnn],ImpExpSubSpec))+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut54 #-}+happyIn55 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn55 #-}+happyOut55 :: (HappyAbsSyn ) -> (([AddAnn], [Located ImpExpQcSpec]))+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut55 #-}+happyIn56 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn56 #-}+happyOut56 :: (HappyAbsSyn ) -> (([AddAnn], [Located ImpExpQcSpec]))+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut56 #-}+happyIn57 :: (Located ([AddAnn], Located ImpExpQcSpec)) -> (HappyAbsSyn )+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn57 #-}+happyOut57 :: (HappyAbsSyn ) -> (Located ([AddAnn], Located ImpExpQcSpec))+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut57 #-}+happyIn58 :: (Located ImpExpQcSpec) -> (HappyAbsSyn )+happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn58 #-}+happyOut58 :: (HappyAbsSyn ) -> (Located ImpExpQcSpec)+happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut58 #-}+happyIn59 :: (Located RdrName) -> (HappyAbsSyn )+happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn59 #-}+happyOut59 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut59 #-}+happyIn60 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn60 #-}+happyOut60 :: (HappyAbsSyn ) -> ([AddAnn])+happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut60 #-}+happyIn61 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn61 #-}+happyOut61 :: (HappyAbsSyn ) -> ([AddAnn])+happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut61 #-}+happyIn62 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn62 #-}+happyOut62 :: (HappyAbsSyn ) -> ([LImportDecl GhcPs])+happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut62 #-}+happyIn63 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn63 #-}+happyOut63 :: (HappyAbsSyn ) -> ([LImportDecl GhcPs])+happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut63 #-}+happyIn64 :: (LImportDecl GhcPs) -> (HappyAbsSyn )+happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn64 #-}+happyOut64 :: (HappyAbsSyn ) -> (LImportDecl GhcPs)+happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut64 #-}+happyIn65 :: ((([AddAnn],SourceText),IsBootInterface)) -> (HappyAbsSyn )+happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn65 #-}+happyOut65 :: (HappyAbsSyn ) -> ((([AddAnn],SourceText),IsBootInterface))+happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut65 #-}+happyIn66 :: (([AddAnn],Bool)) -> (HappyAbsSyn )+happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn66 #-}+happyOut66 :: (HappyAbsSyn ) -> (([AddAnn],Bool))+happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut66 #-}+happyIn67 :: (([AddAnn],Maybe StringLiteral)) -> (HappyAbsSyn )+happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn67 #-}+happyOut67 :: (HappyAbsSyn ) -> (([AddAnn],Maybe StringLiteral))+happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut67 #-}+happyIn68 :: (([AddAnn],Bool)) -> (HappyAbsSyn )+happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn68 #-}+happyOut68 :: (HappyAbsSyn ) -> (([AddAnn],Bool))+happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut68 #-}+happyIn69 :: (([AddAnn],Located (Maybe (Located ModuleName)))) -> (HappyAbsSyn )+happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn69 #-}+happyOut69 :: (HappyAbsSyn ) -> (([AddAnn],Located (Maybe (Located ModuleName))))+happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut69 #-}+happyIn70 :: (Located (Maybe (Bool, Located [LIE GhcPs]))) -> (HappyAbsSyn )+happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn70 #-}+happyOut70 :: (HappyAbsSyn ) -> (Located (Maybe (Bool, Located [LIE GhcPs])))+happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut70 #-}+happyIn71 :: (Located (Bool, Located [LIE GhcPs])) -> (HappyAbsSyn )+happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn71 #-}+happyOut71 :: (HappyAbsSyn ) -> (Located (Bool, Located [LIE GhcPs]))+happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut71 #-}+happyIn72 :: (Located (SourceText,Int)) -> (HappyAbsSyn )+happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn72 #-}+happyOut72 :: (HappyAbsSyn ) -> (Located (SourceText,Int))+happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut72 #-}+happyIn73 :: (Located FixityDirection) -> (HappyAbsSyn )+happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn73 #-}+happyOut73 :: (HappyAbsSyn ) -> (Located FixityDirection)+happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut73 #-}+happyIn74 :: (Located (OrdList (Located RdrName))) -> (HappyAbsSyn )+happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn74 #-}+happyOut74 :: (HappyAbsSyn ) -> (Located (OrdList (Located RdrName)))+happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut74 #-}+happyIn75 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )+happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn75 #-}+happyOut75 :: (HappyAbsSyn ) -> (OrdList (LHsDecl GhcPs))+happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut75 #-}+happyIn76 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )+happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn76 #-}+happyOut76 :: (HappyAbsSyn ) -> (OrdList (LHsDecl GhcPs))+happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut76 #-}+happyIn77 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn77 #-}+happyOut77 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut77 #-}+happyIn78 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )+happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn78 #-}+happyOut78 :: (HappyAbsSyn ) -> (LTyClDecl GhcPs)+happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut78 #-}+happyIn79 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )+happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn79 #-}+happyOut79 :: (HappyAbsSyn ) -> (LTyClDecl GhcPs)+happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut79 #-}+happyIn80 :: (LInstDecl GhcPs) -> (HappyAbsSyn )+happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn80 #-}+happyOut80 :: (HappyAbsSyn ) -> (LInstDecl GhcPs)+happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut80 #-}+happyIn81 :: (Maybe (Located OverlapMode)) -> (HappyAbsSyn )+happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn81 #-}+happyOut81 :: (HappyAbsSyn ) -> (Maybe (Located OverlapMode))+happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut81 #-}+happyIn82 :: (Maybe (Located DerivStrategy)) -> (HappyAbsSyn )+happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn82 #-}+happyOut82 :: (HappyAbsSyn ) -> (Maybe (Located DerivStrategy))+happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut82 #-}+happyIn83 :: (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))) -> (HappyAbsSyn )+happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn83 #-}+happyOut83 :: (HappyAbsSyn ) -> (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)))+happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut83 #-}+happyIn84 :: (LInjectivityAnn GhcPs) -> (HappyAbsSyn )+happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn84 #-}+happyOut84 :: (HappyAbsSyn ) -> (LInjectivityAnn GhcPs)+happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut84 #-}+happyIn85 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn85 #-}+happyOut85 :: (HappyAbsSyn ) -> (Located [Located RdrName])+happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut85 #-}+happyIn86 :: (Located ([AddAnn],FamilyInfo GhcPs)) -> (HappyAbsSyn )+happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn86 #-}+happyOut86 :: (HappyAbsSyn ) -> (Located ([AddAnn],FamilyInfo GhcPs))+happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut86 #-}+happyIn87 :: (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs])) -> (HappyAbsSyn )+happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn87 #-}+happyOut87 :: (HappyAbsSyn ) -> (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]))+happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut87 #-}+happyIn88 :: (Located [LTyFamInstEqn GhcPs]) -> (HappyAbsSyn )+happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn88 #-}+happyOut88 :: (HappyAbsSyn ) -> (Located [LTyFamInstEqn GhcPs])+happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut88 #-}+happyIn89 :: (Located ([AddAnn],TyFamInstEqn GhcPs)) -> (HappyAbsSyn )+happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn89 #-}+happyOut89 :: (HappyAbsSyn ) -> (Located ([AddAnn],TyFamInstEqn GhcPs))+happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut89 #-}+happyIn90 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn90 #-}+happyOut90 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut90 #-}+happyIn91 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn91 #-}+happyOut91 :: (HappyAbsSyn ) -> ([AddAnn])+happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut91 #-}+happyIn92 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn92 #-}+happyOut92 :: (HappyAbsSyn ) -> ([AddAnn])+happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut92 #-}+happyIn93 :: (LInstDecl GhcPs) -> (HappyAbsSyn )+happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn93 #-}+happyOut93 :: (HappyAbsSyn ) -> (LInstDecl GhcPs)+happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut93 #-}+happyIn94 :: (Located (AddAnn, NewOrData)) -> (HappyAbsSyn )+happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn94 #-}+happyOut94 :: (HappyAbsSyn ) -> (Located (AddAnn, NewOrData))+happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut94 #-}+happyIn95 :: (Located ([AddAnn], Maybe (LHsKind GhcPs))) -> (HappyAbsSyn )+happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn95 #-}+happyOut95 :: (HappyAbsSyn ) -> (Located ([AddAnn], Maybe (LHsKind GhcPs)))+happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut95 #-}+happyIn96 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )+happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn96 #-}+happyOut96 :: (HappyAbsSyn ) -> (Located ([AddAnn], LFamilyResultSig GhcPs))+happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut96 #-}+happyIn97 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )+happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn97 #-}+happyOut97 :: (HappyAbsSyn ) -> (Located ([AddAnn], LFamilyResultSig GhcPs))+happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut97 #-}+happyIn98 :: (Located ([AddAnn], ( LFamilyResultSig GhcPs+ , Maybe (LInjectivityAnn GhcPs)))) -> (HappyAbsSyn )+happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn98 #-}+happyOut98 :: (HappyAbsSyn ) -> (Located ([AddAnn], ( LFamilyResultSig GhcPs+ , Maybe (LInjectivityAnn GhcPs))))+happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut98 #-}+happyIn99 :: (Located (Maybe (LHsContext GhcPs), LHsType GhcPs)) -> (HappyAbsSyn )+happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn99 #-}+happyOut99 :: (HappyAbsSyn ) -> (Located (Maybe (LHsContext GhcPs), LHsType GhcPs))+happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut99 #-}+happyIn100 :: (Maybe (Located CType)) -> (HappyAbsSyn )+happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn100 #-}+happyOut100 :: (HappyAbsSyn ) -> (Maybe (Located CType))+happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut100 #-}+happyIn101 :: (LDerivDecl GhcPs) -> (HappyAbsSyn )+happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn101 #-}+happyOut101 :: (HappyAbsSyn ) -> (LDerivDecl GhcPs)+happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut101 #-}+happyIn102 :: (LRoleAnnotDecl GhcPs) -> (HappyAbsSyn )+happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn102 #-}+happyOut102 :: (HappyAbsSyn ) -> (LRoleAnnotDecl GhcPs)+happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut102 #-}+happyIn103 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )+happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn103 #-}+happyOut103 :: (HappyAbsSyn ) -> (Located [Located (Maybe FastString)])+happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut103 #-}+happyIn104 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )+happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn104 #-}+happyOut104 :: (HappyAbsSyn ) -> (Located [Located (Maybe FastString)])+happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut104 #-}+happyIn105 :: (Located (Maybe FastString)) -> (HappyAbsSyn )+happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn105 #-}+happyOut105 :: (HappyAbsSyn ) -> (Located (Maybe FastString))+happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut105 #-}+happyIn106 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn106 #-}+happyOut106 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut106 #-}+happyIn107 :: ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])) -> (HappyAbsSyn )+happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn107 #-}+happyOut107 :: (HappyAbsSyn ) -> ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]))+happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut107 #-}+happyIn108 :: ([Located RdrName]) -> (HappyAbsSyn )+happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn108 #-}+happyOut108 :: (HappyAbsSyn ) -> ([Located RdrName])+happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut108 #-}+happyIn109 :: ([RecordPatSynField (Located RdrName)]) -> (HappyAbsSyn )+happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn109 #-}+happyOut109 :: (HappyAbsSyn ) -> ([RecordPatSynField (Located RdrName)])+happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut109 #-}+happyIn110 :: (Located ([AddAnn]+ , Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )+happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn110 #-}+happyOut110 :: (HappyAbsSyn ) -> (Located ([AddAnn]+ , Located (OrdList (LHsDecl GhcPs))))+happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut110 #-}+happyIn111 :: (LSig GhcPs) -> (HappyAbsSyn )+happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn111 #-}+happyOut111 :: (HappyAbsSyn ) -> (LSig GhcPs)+happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut111 #-}+happyIn112 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn112 #-}+happyOut112 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut112 #-}+happyIn113 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn113 #-}+happyOut113 :: (HappyAbsSyn ) -> (Located ([AddAnn],OrdList (LHsDecl GhcPs)))+happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut113 #-}+happyIn114 :: (Located ([AddAnn]+ , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn114 #-}+happyOut114 :: (HappyAbsSyn ) -> (Located ([AddAnn]+ , OrdList (LHsDecl GhcPs)))+happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut114 #-}+happyIn115 :: (Located ([AddAnn]+ ,(OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )+happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn115 #-}+happyOut115 :: (HappyAbsSyn ) -> (Located ([AddAnn]+ ,(OrdList (LHsDecl GhcPs))))+happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut115 #-}+happyIn116 :: (Located (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn116 #-}+happyOut116 :: (HappyAbsSyn ) -> (Located (OrdList (LHsDecl GhcPs)))+happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut116 #-}+happyIn117 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn117 #-}+happyOut117 :: (HappyAbsSyn ) -> (Located ([AddAnn],OrdList (LHsDecl GhcPs)))+happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut117 #-}+happyIn118 :: (Located ([AddAnn]+ , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn118 #-}+happyOut118 :: (HappyAbsSyn ) -> (Located ([AddAnn]+ , OrdList (LHsDecl GhcPs)))+happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut118 #-}+happyIn119 :: (Located ([AddAnn]+ , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn119 #-}+happyOut119 :: (HappyAbsSyn ) -> (Located ([AddAnn]+ , OrdList (LHsDecl GhcPs)))+happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut119 #-}+happyIn120 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn120 #-}+happyOut120 :: (HappyAbsSyn ) -> (Located ([AddAnn],OrdList (LHsDecl GhcPs)))+happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut120 #-}+happyIn121 :: (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )+happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn121 #-}+happyOut121 :: (HappyAbsSyn ) -> (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs))))+happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut121 #-}+happyIn122 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )+happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn122 #-}+happyOut122 :: (HappyAbsSyn ) -> (Located ([AddAnn],Located (HsLocalBinds GhcPs)))+happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut122 #-}+happyIn123 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )+happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn123 #-}+happyOut123 :: (HappyAbsSyn ) -> (Located ([AddAnn],Located (HsLocalBinds GhcPs)))+happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut123 #-}+happyIn124 :: (OrdList (LRuleDecl GhcPs)) -> (HappyAbsSyn )+happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn124 #-}+happyOut124 :: (HappyAbsSyn ) -> (OrdList (LRuleDecl GhcPs))+happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut124 #-}+happyIn125 :: (LRuleDecl GhcPs) -> (HappyAbsSyn )+happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn125 #-}+happyOut125 :: (HappyAbsSyn ) -> (LRuleDecl GhcPs)+happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut125 #-}+happyIn126 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )+happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn126 #-}+happyOut126 :: (HappyAbsSyn ) -> (([AddAnn],Maybe Activation))+happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut126 #-}+happyIn127 :: (([AddAnn]+ ,Activation)) -> (HappyAbsSyn )+happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn127 #-}+happyOut127 :: (HappyAbsSyn ) -> (([AddAnn]+ ,Activation))+happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut127 #-}+happyIn128 :: (([AddAnn],[LRuleBndr GhcPs])) -> (HappyAbsSyn )+happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn128 #-}+happyOut128 :: (HappyAbsSyn ) -> (([AddAnn],[LRuleBndr GhcPs]))+happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut128 #-}+happyIn129 :: ([LRuleBndr GhcPs]) -> (HappyAbsSyn )+happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn129 #-}+happyOut129 :: (HappyAbsSyn ) -> ([LRuleBndr GhcPs])+happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut129 #-}+happyIn130 :: (LRuleBndr GhcPs) -> (HappyAbsSyn )+happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn130 #-}+happyOut130 :: (HappyAbsSyn ) -> (LRuleBndr GhcPs)+happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut130 #-}+happyIn131 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn131 #-}+happyOut131 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl GhcPs))+happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut131 #-}+happyIn132 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn132 #-}+happyOut132 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl GhcPs))+happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut132 #-}+happyIn133 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn133 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn133 #-}+happyOut133 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl GhcPs))+happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut133 #-}+happyIn134 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn134 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn134 #-}+happyOut134 :: (HappyAbsSyn ) -> (OrdList (LWarnDecl GhcPs))+happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut134 #-}+happyIn135 :: (Located ([AddAnn],[Located StringLiteral])) -> (HappyAbsSyn )+happyIn135 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn135 #-}+happyOut135 :: (HappyAbsSyn ) -> (Located ([AddAnn],[Located StringLiteral]))+happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut135 #-}+happyIn136 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )+happyIn136 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn136 #-}+happyOut136 :: (HappyAbsSyn ) -> (Located (OrdList (Located StringLiteral)))+happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut136 #-}+happyIn137 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn137 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn137 #-}+happyOut137 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut137 #-}+happyIn138 :: (Located ([AddAnn],HsDecl GhcPs)) -> (HappyAbsSyn )+happyIn138 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn138 #-}+happyOut138 :: (HappyAbsSyn ) -> (Located ([AddAnn],HsDecl GhcPs))+happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut138 #-}+happyIn139 :: (Located CCallConv) -> (HappyAbsSyn )+happyIn139 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn139 #-}+happyOut139 :: (HappyAbsSyn ) -> (Located CCallConv)+happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut139 #-}+happyIn140 :: (Located Safety) -> (HappyAbsSyn )+happyIn140 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn140 #-}+happyOut140 :: (HappyAbsSyn ) -> (Located Safety)+happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut140 #-}+happyIn141 :: (Located ([AddAnn]+ ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs))) -> (HappyAbsSyn )+happyIn141 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn141 #-}+happyOut141 :: (HappyAbsSyn ) -> (Located ([AddAnn]+ ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)))+happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut141 #-}+happyIn142 :: (([AddAnn], Maybe (LHsType GhcPs))) -> (HappyAbsSyn )+happyIn142 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn142 #-}+happyOut142 :: (HappyAbsSyn ) -> (([AddAnn], Maybe (LHsType GhcPs)))+happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut142 #-}+happyIn143 :: (([AddAnn], Maybe (Located RdrName))) -> (HappyAbsSyn )+happyIn143 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn143 #-}+happyOut143 :: (HappyAbsSyn ) -> (([AddAnn], Maybe (Located RdrName)))+happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut143 #-}+happyIn144 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn144 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn144 #-}+happyOut144 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut144 #-}+happyIn145 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn145 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn145 #-}+happyOut145 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut145 #-}+happyIn146 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn146 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn146 #-}+happyOut146 :: (HappyAbsSyn ) -> (Located [Located RdrName])+happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut146 #-}+happyIn147 :: ((OrdList (LHsSigType GhcPs))) -> (HappyAbsSyn )+happyIn147 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn147 #-}+happyOut147 :: (HappyAbsSyn ) -> ((OrdList (LHsSigType GhcPs)))+happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut147 #-}+happyIn148 :: (Located ([AddAnn],HsSrcBang)) -> (HappyAbsSyn )+happyIn148 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn148 #-}+happyOut148 :: (HappyAbsSyn ) -> (Located ([AddAnn],HsSrcBang))+happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut148 #-}+happyIn149 :: (Located ([AddAnn], SrcStrictness)) -> (HappyAbsSyn )+happyIn149 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn149 #-}+happyOut149 :: (HappyAbsSyn ) -> (Located ([AddAnn], SrcStrictness))+happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut149 #-}+happyIn150 :: (Located ([AddAnn], SourceText, SrcUnpackedness)) -> (HappyAbsSyn )+happyIn150 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn150 #-}+happyOut150 :: (HappyAbsSyn ) -> (Located ([AddAnn], SourceText, SrcUnpackedness))+happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut150 #-}+happyIn151 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn151 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn151 #-}+happyOut151 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut151 #-}+happyIn152 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn152 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn152 #-}+happyOut152 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut152 #-}+happyIn153 :: (LHsContext GhcPs) -> (HappyAbsSyn )+happyIn153 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn153 #-}+happyOut153 :: (HappyAbsSyn ) -> (LHsContext GhcPs)+happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut153 #-}+happyIn154 :: (LHsContext GhcPs) -> (HappyAbsSyn )+happyIn154 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn154 #-}+happyOut154 :: (HappyAbsSyn ) -> (LHsContext GhcPs)+happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut154 #-}+happyIn155 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn155 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn155 #-}+happyOut155 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut155 #-}+happyIn156 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn156 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn156 #-}+happyOut156 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut156 #-}+happyIn157 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn157 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn157 #-}+happyOut157 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut157 #-}+happyIn158 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn158 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn158 #-}+happyOut158 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut158 #-}+happyIn159 :: (Located [LHsAppType GhcPs]) -> (HappyAbsSyn )+happyIn159 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn159 #-}+happyOut159 :: (HappyAbsSyn ) -> (Located [LHsAppType GhcPs])+happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut159 #-}+happyIn160 :: (LHsAppType GhcPs) -> (HappyAbsSyn )+happyIn160 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn160 #-}+happyOut160 :: (HappyAbsSyn ) -> (LHsAppType GhcPs)+happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut160 #-}+happyIn161 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn161 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn161 #-}+happyOut161 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut161 #-}+happyIn162 :: (LHsSigType GhcPs) -> (HappyAbsSyn )+happyIn162 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn162 #-}+happyOut162 :: (HappyAbsSyn ) -> (LHsSigType GhcPs)+happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut162 #-}+happyIn163 :: ([LHsSigType GhcPs]) -> (HappyAbsSyn )+happyIn163 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn163 #-}+happyOut163 :: (HappyAbsSyn ) -> ([LHsSigType GhcPs])+happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut163 #-}+happyIn164 :: ([LHsType GhcPs]) -> (HappyAbsSyn )+happyIn164 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn164 #-}+happyOut164 :: (HappyAbsSyn ) -> ([LHsType GhcPs])+happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut164 #-}+happyIn165 :: ([LHsType GhcPs]) -> (HappyAbsSyn )+happyIn165 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn165 #-}+happyOut165 :: (HappyAbsSyn ) -> ([LHsType GhcPs])+happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut165 #-}+happyIn166 :: ([LHsType GhcPs]) -> (HappyAbsSyn )+happyIn166 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn166 #-}+happyOut166 :: (HappyAbsSyn ) -> ([LHsType GhcPs])+happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut166 #-}+happyIn167 :: ([LHsTyVarBndr GhcPs]) -> (HappyAbsSyn )+happyIn167 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn167 #-}+happyOut167 :: (HappyAbsSyn ) -> ([LHsTyVarBndr GhcPs])+happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut167 #-}+happyIn168 :: (LHsTyVarBndr GhcPs) -> (HappyAbsSyn )+happyIn168 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn168 #-}+happyOut168 :: (HappyAbsSyn ) -> (LHsTyVarBndr GhcPs)+happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut168 #-}+happyIn169 :: (Located ([AddAnn],[Located (FunDep (Located RdrName))])) -> (HappyAbsSyn )+happyIn169 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn169 #-}+happyOut169 :: (HappyAbsSyn ) -> (Located ([AddAnn],[Located (FunDep (Located RdrName))]))+happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut169 #-}+happyIn170 :: (Located [Located (FunDep (Located RdrName))]) -> (HappyAbsSyn )+happyIn170 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn170 #-}+happyOut170 :: (HappyAbsSyn ) -> (Located [Located (FunDep (Located RdrName))])+happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut170 #-}+happyIn171 :: (Located (FunDep (Located RdrName))) -> (HappyAbsSyn )+happyIn171 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn171 #-}+happyOut171 :: (HappyAbsSyn ) -> (Located (FunDep (Located RdrName)))+happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut171 #-}+happyIn172 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn172 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn172 #-}+happyOut172 :: (HappyAbsSyn ) -> (Located [Located RdrName])+happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut172 #-}+happyIn173 :: (LHsKind GhcPs) -> (HappyAbsSyn )+happyIn173 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn173 #-}+happyOut173 :: (HappyAbsSyn ) -> (LHsKind GhcPs)+happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut173 #-}+happyIn174 :: (Located ([AddAnn]+ ,[LConDecl GhcPs])) -> (HappyAbsSyn )+happyIn174 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn174 #-}+happyOut174 :: (HappyAbsSyn ) -> (Located ([AddAnn]+ ,[LConDecl GhcPs]))+happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut174 #-}+happyIn175 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )+happyIn175 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn175 #-}+happyOut175 :: (HappyAbsSyn ) -> (Located [LConDecl GhcPs])+happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut175 #-}+happyIn176 :: (LConDecl GhcPs) -> (HappyAbsSyn )+happyIn176 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn176 #-}+happyOut176 :: (HappyAbsSyn ) -> (LConDecl GhcPs)+happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut176 #-}+happyIn177 :: (LConDecl GhcPs) -> (HappyAbsSyn )+happyIn177 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn177 #-}+happyOut177 :: (HappyAbsSyn ) -> (LConDecl GhcPs)+happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut177 #-}+happyIn178 :: (Located ([AddAnn],[LConDecl GhcPs])) -> (HappyAbsSyn )+happyIn178 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn178 #-}+happyOut178 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LConDecl GhcPs]))+happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut178 #-}+happyIn179 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )+happyIn179 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn179 #-}+happyOut179 :: (HappyAbsSyn ) -> (Located [LConDecl GhcPs])+happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut179 #-}+happyIn180 :: (LConDecl GhcPs) -> (HappyAbsSyn )+happyIn180 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn180 #-}+happyOut180 :: (HappyAbsSyn ) -> (LConDecl GhcPs)+happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut180 #-}+happyIn181 :: (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])) -> (HappyAbsSyn )+happyIn181 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn181 #-}+happyOut181 :: (HappyAbsSyn ) -> (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]))+happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut181 #-}+happyIn182 :: (Located (Located RdrName, HsConDeclDetails GhcPs)) -> (HappyAbsSyn )+happyIn182 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn182 #-}+happyOut182 :: (HappyAbsSyn ) -> (Located (Located RdrName, HsConDeclDetails GhcPs))+happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut182 #-}+happyIn183 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )+happyIn183 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn183 #-}+happyOut183 :: (HappyAbsSyn ) -> ([LConDeclField GhcPs])+happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut183 #-}+happyIn184 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )+happyIn184 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn184 #-}+happyOut184 :: (HappyAbsSyn ) -> ([LConDeclField GhcPs])+happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut184 #-}+happyIn185 :: (LConDeclField GhcPs) -> (HappyAbsSyn )+happyIn185 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn185 #-}+happyOut185 :: (HappyAbsSyn ) -> (LConDeclField GhcPs)+happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut185 #-}+happyIn186 :: (HsDeriving GhcPs) -> (HappyAbsSyn )+happyIn186 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn186 #-}+happyOut186 :: (HappyAbsSyn ) -> (HsDeriving GhcPs)+happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut186 #-}+happyIn187 :: (HsDeriving GhcPs) -> (HappyAbsSyn )+happyIn187 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn187 #-}+happyOut187 :: (HappyAbsSyn ) -> (HsDeriving GhcPs)+happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut187 #-}+happyIn188 :: (LHsDerivingClause GhcPs) -> (HappyAbsSyn )+happyIn188 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn188 #-}+happyOut188 :: (HappyAbsSyn ) -> (LHsDerivingClause GhcPs)+happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut188 #-}+happyIn189 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn189 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn189 #-}+happyOut189 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut189 #-}+happyIn190 :: (LDocDecl) -> (HappyAbsSyn )+happyIn190 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn190 #-}+happyOut190 :: (HappyAbsSyn ) -> (LDocDecl)+happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut190 #-}+happyIn191 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn191 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn191 #-}+happyOut191 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut191 #-}+happyIn192 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn192 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn192 #-}+happyOut192 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut192 #-}+happyIn193 :: (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )+happyIn193 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn193 #-}+happyOut193 :: (HappyAbsSyn ) -> (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)))+happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut193 #-}+happyIn194 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn194 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn194 #-}+happyOut194 :: (HappyAbsSyn ) -> (Located [LGRHS GhcPs (LHsExpr GhcPs)])+happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut194 #-}+happyIn195 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn195 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn195 #-}+happyOut195 :: (HappyAbsSyn ) -> (LGRHS GhcPs (LHsExpr GhcPs))+happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut195 #-}+happyIn196 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn196 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn196 #-}+happyOut196 :: (HappyAbsSyn ) -> (LHsDecl GhcPs)+happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut196 #-}+happyIn197 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )+happyIn197 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn197 #-}+happyOut197 :: (HappyAbsSyn ) -> (([AddAnn],Maybe Activation))+happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut197 #-}+happyIn198 :: (([AddAnn],Activation)) -> (HappyAbsSyn )+happyIn198 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn198 #-}+happyOut198 :: (HappyAbsSyn ) -> (([AddAnn],Activation))+happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut198 #-}+happyIn199 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )+happyIn199 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn199 #-}+happyOut199 :: (HappyAbsSyn ) -> (Located (HsSplice GhcPs))+happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut199 #-}+happyIn200 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn200 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn200 #-}+happyOut200 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut200 #-}+happyIn201 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn201 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn201 #-}+happyOut201 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut201 #-}+happyIn202 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn202 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn202 #-}+happyOut202 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut202 #-}+happyIn203 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn203 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn203 #-}+happyOut203 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut203 #-}+happyIn204 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn204 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn204 #-}+happyOut204 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut204 #-}+happyIn205 :: (([Located a],Bool)) -> (HappyAbsSyn )+happyIn205 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn205 #-}+happyOut205 :: (HappyAbsSyn ) -> (([Located a],Bool))+happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut205 #-}+happyIn206 :: (Located (([AddAnn],SourceText),StringLiteral)) -> (HappyAbsSyn )+happyIn206 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn206 #-}+happyOut206 :: (HappyAbsSyn ) -> (Located (([AddAnn],SourceText),StringLiteral))+happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut206 #-}+happyIn207 :: (Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),+ ((SourceText,SourceText),(SourceText,SourceText))+ )) -> (HappyAbsSyn )+happyIn207 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn207 #-}+happyOut207 :: (HappyAbsSyn ) -> (Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),+ ((SourceText,SourceText),(SourceText,SourceText))+ ))+happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut207 #-}+happyIn208 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn208 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn208 #-}+happyOut208 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut208 #-}+happyIn209 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn209 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn209 #-}+happyOut209 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut209 #-}+happyIn210 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn210 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn210 #-}+happyOut210 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut210 #-}+happyIn211 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn211 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn211 #-}+happyOut211 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut211 #-}+happyIn212 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn212 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn212 #-}+happyOut212 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut212 #-}+happyIn213 :: ([LHsCmdTop GhcPs]) -> (HappyAbsSyn )+happyIn213 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn213 #-}+happyOut213 :: (HappyAbsSyn ) -> ([LHsCmdTop GhcPs])+happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut213 #-}+happyIn214 :: (LHsCmdTop GhcPs) -> (HappyAbsSyn )+happyIn214 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn214 #-}+happyOut214 :: (HappyAbsSyn ) -> (LHsCmdTop GhcPs)+happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut214 #-}+happyIn215 :: (([AddAnn],[LHsDecl GhcPs])) -> (HappyAbsSyn )+happyIn215 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn215 #-}+happyOut215 :: (HappyAbsSyn ) -> (([AddAnn],[LHsDecl GhcPs]))+happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut215 #-}+happyIn216 :: ([LHsDecl GhcPs]) -> (HappyAbsSyn )+happyIn216 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn216 #-}+happyOut216 :: (HappyAbsSyn ) -> ([LHsDecl GhcPs])+happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut216 #-}+happyIn217 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn217 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn217 #-}+happyOut217 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut217 #-}+happyIn218 :: (([AddAnn],SumOrTuple)) -> (HappyAbsSyn )+happyIn218 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn218 #-}+happyOut218 :: (HappyAbsSyn ) -> (([AddAnn],SumOrTuple))+happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut218 #-}+happyIn219 :: ((SrcSpan,[LHsTupArg GhcPs])) -> (HappyAbsSyn )+happyIn219 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn219 #-}+happyOut219 :: (HappyAbsSyn ) -> ((SrcSpan,[LHsTupArg GhcPs]))+happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut219 #-}+happyIn220 :: ([LHsTupArg GhcPs]) -> (HappyAbsSyn )+happyIn220 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn220 #-}+happyOut220 :: (HappyAbsSyn ) -> ([LHsTupArg GhcPs])+happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut220 #-}+happyIn221 :: (([AddAnn],HsExpr GhcPs)) -> (HappyAbsSyn )+happyIn221 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn221 #-}+happyOut221 :: (HappyAbsSyn ) -> (([AddAnn],HsExpr GhcPs))+happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut221 #-}+happyIn222 :: (Located [LHsExpr GhcPs]) -> (HappyAbsSyn )+happyIn222 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn222 #-}+happyOut222 :: (HappyAbsSyn ) -> (Located [LHsExpr GhcPs])+happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut222 #-}+happyIn223 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn223 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn223 #-}+happyOut223 :: (HappyAbsSyn ) -> (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut223 #-}+happyIn224 :: (Located [[LStmt GhcPs (LHsExpr GhcPs)]]) -> (HappyAbsSyn )+happyIn224 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn224 #-}+happyOut224 :: (HappyAbsSyn ) -> (Located [[LStmt GhcPs (LHsExpr GhcPs)]])+happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut224 #-}+happyIn225 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn225 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn225 #-}+happyOut225 :: (HappyAbsSyn ) -> (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyOut225 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut225 #-}+happyIn226 :: (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )+happyIn226 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn226 #-}+happyOut226 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs)))+happyOut226 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut226 #-}+happyIn227 :: (([AddAnn],HsExpr GhcPs)) -> (HappyAbsSyn )+happyIn227 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn227 #-}+happyOut227 :: (HappyAbsSyn ) -> (([AddAnn],HsExpr GhcPs))+happyOut227 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut227 #-}+happyIn228 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn228 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn228 #-}+happyOut228 :: (HappyAbsSyn ) -> (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyOut228 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut228 #-}+happyIn229 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn229 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn229 #-}+happyOut229 :: (HappyAbsSyn ) -> (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyOut229 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut229 #-}+happyIn230 :: (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )+happyIn230 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn230 #-}+happyOut230 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]))+happyOut230 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut230 #-}+happyIn231 :: (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )+happyIn231 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn231 #-}+happyOut231 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]))+happyOut231 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut231 #-}+happyIn232 :: (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )+happyIn232 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn232 #-}+happyOut232 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]))+happyOut232 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut232 #-}+happyIn233 :: (LMatch GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn233 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn233 #-}+happyOut233 :: (HappyAbsSyn ) -> (LMatch GhcPs (LHsExpr GhcPs))+happyOut233 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut233 #-}+happyIn234 :: (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )+happyIn234 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn234 #-}+happyOut234 :: (HappyAbsSyn ) -> (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)))+happyOut234 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut234 #-}+happyIn235 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn235 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn235 #-}+happyOut235 :: (HappyAbsSyn ) -> (Located [LGRHS GhcPs (LHsExpr GhcPs)])+happyOut235 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut235 #-}+happyIn236 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn236 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn236 #-}+happyOut236 :: (HappyAbsSyn ) -> (Located [LGRHS GhcPs (LHsExpr GhcPs)])+happyOut236 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut236 #-}+happyIn237 :: (Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )+happyIn237 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn237 #-}+happyOut237 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)]))+happyOut237 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut237 #-}+happyIn238 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn238 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn238 #-}+happyOut238 :: (HappyAbsSyn ) -> (LGRHS GhcPs (LHsExpr GhcPs))+happyOut238 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut238 #-}+happyIn239 :: (LPat GhcPs) -> (HappyAbsSyn )+happyIn239 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn239 #-}+happyOut239 :: (HappyAbsSyn ) -> (LPat GhcPs)+happyOut239 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut239 #-}+happyIn240 :: (LPat GhcPs) -> (HappyAbsSyn )+happyIn240 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn240 #-}+happyOut240 :: (HappyAbsSyn ) -> (LPat GhcPs)+happyOut240 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut240 #-}+happyIn241 :: (LPat GhcPs) -> (HappyAbsSyn )+happyIn241 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn241 #-}+happyOut241 :: (HappyAbsSyn ) -> (LPat GhcPs)+happyOut241 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut241 #-}+happyIn242 :: ([LPat GhcPs]) -> (HappyAbsSyn )+happyIn242 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn242 #-}+happyOut242 :: (HappyAbsSyn ) -> ([LPat GhcPs])+happyOut242 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut242 #-}+happyIn243 :: (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )+happyIn243 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn243 #-}+happyOut243 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)]))+happyOut243 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut243 #-}+happyIn244 :: (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )+happyIn244 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn244 #-}+happyOut244 :: (HappyAbsSyn ) -> (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)]))+happyOut244 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut244 #-}+happyIn245 :: (Maybe (LStmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )+happyIn245 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn245 #-}+happyOut245 :: (HappyAbsSyn ) -> (Maybe (LStmt GhcPs (LHsExpr GhcPs)))+happyOut245 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut245 #-}+happyIn246 :: (LStmt GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn246 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn246 #-}+happyOut246 :: (HappyAbsSyn ) -> (LStmt GhcPs (LHsExpr GhcPs))+happyOut246 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut246 #-}+happyIn247 :: (LStmt GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn247 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn247 #-}+happyOut247 :: (HappyAbsSyn ) -> (LStmt GhcPs (LHsExpr GhcPs))+happyOut247 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut247 #-}+happyIn248 :: (([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool))) -> (HappyAbsSyn )+happyIn248 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn248 #-}+happyOut248 :: (HappyAbsSyn ) -> (([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool)))+happyOut248 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut248 #-}+happyIn249 :: (([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool))) -> (HappyAbsSyn )+happyIn249 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn249 #-}+happyOut249 :: (HappyAbsSyn ) -> (([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool)))+happyOut249 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut249 #-}+happyIn250 :: (LHsRecField GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn250 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn250 #-}+happyOut250 :: (HappyAbsSyn ) -> (LHsRecField GhcPs (LHsExpr GhcPs))+happyOut250 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut250 #-}+happyIn251 :: (Located [LIPBind GhcPs]) -> (HappyAbsSyn )+happyIn251 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn251 #-}+happyOut251 :: (HappyAbsSyn ) -> (Located [LIPBind GhcPs])+happyOut251 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut251 #-}+happyIn252 :: (LIPBind GhcPs) -> (HappyAbsSyn )+happyIn252 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn252 #-}+happyOut252 :: (HappyAbsSyn ) -> (LIPBind GhcPs)+happyOut252 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut252 #-}+happyIn253 :: (Located HsIPName) -> (HappyAbsSyn )+happyIn253 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn253 #-}+happyOut253 :: (HappyAbsSyn ) -> (Located HsIPName)+happyOut253 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut253 #-}+happyIn254 :: (Located FastString) -> (HappyAbsSyn )+happyIn254 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn254 #-}+happyOut254 :: (HappyAbsSyn ) -> (Located FastString)+happyOut254 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut254 #-}+happyIn255 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn255 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn255 #-}+happyOut255 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))+happyOut255 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut255 #-}+happyIn256 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn256 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn256 #-}+happyOut256 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))+happyOut256 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut256 #-}+happyIn257 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn257 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn257 #-}+happyOut257 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))+happyOut257 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut257 #-}+happyIn258 :: ([LBooleanFormula (Located RdrName)]) -> (HappyAbsSyn )+happyIn258 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn258 #-}+happyOut258 :: (HappyAbsSyn ) -> ([LBooleanFormula (Located RdrName)])+happyOut258 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut258 #-}+happyIn259 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn259 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn259 #-}+happyOut259 :: (HappyAbsSyn ) -> (LBooleanFormula (Located RdrName))+happyOut259 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut259 #-}+happyIn260 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn260 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn260 #-}+happyOut260 :: (HappyAbsSyn ) -> (Located [Located RdrName])+happyOut260 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut260 #-}+happyIn261 :: (Located RdrName) -> (HappyAbsSyn )+happyIn261 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn261 #-}+happyOut261 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut261 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut261 #-}+happyIn262 :: (Located RdrName) -> (HappyAbsSyn )+happyIn262 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn262 #-}+happyOut262 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut262 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut262 #-}+happyIn263 :: (Located RdrName) -> (HappyAbsSyn )+happyIn263 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn263 #-}+happyOut263 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut263 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut263 #-}+happyIn264 :: (Located RdrName) -> (HappyAbsSyn )+happyIn264 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn264 #-}+happyOut264 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut264 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut264 #-}+happyIn265 :: (Located RdrName) -> (HappyAbsSyn )+happyIn265 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn265 #-}+happyOut265 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut265 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut265 #-}+happyIn266 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn266 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn266 #-}+happyOut266 :: (HappyAbsSyn ) -> (Located [Located RdrName])+happyOut266 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut266 #-}+happyIn267 :: (Located DataCon) -> (HappyAbsSyn )+happyIn267 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn267 #-}+happyOut267 :: (HappyAbsSyn ) -> (Located DataCon)+happyOut267 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut267 #-}+happyIn268 :: (Located DataCon) -> (HappyAbsSyn )+happyIn268 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn268 #-}+happyOut268 :: (HappyAbsSyn ) -> (Located DataCon)+happyOut268 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut268 #-}+happyIn269 :: (Located RdrName) -> (HappyAbsSyn )+happyIn269 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn269 #-}+happyOut269 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut269 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut269 #-}+happyIn270 :: (Located RdrName) -> (HappyAbsSyn )+happyIn270 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn270 #-}+happyOut270 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut270 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut270 #-}+happyIn271 :: (Located RdrName) -> (HappyAbsSyn )+happyIn271 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn271 #-}+happyOut271 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut271 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut271 #-}+happyIn272 :: (Located RdrName) -> (HappyAbsSyn )+happyIn272 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn272 #-}+happyOut272 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut272 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut272 #-}+happyIn273 :: (Located RdrName) -> (HappyAbsSyn )+happyIn273 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn273 #-}+happyOut273 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut273 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut273 #-}+happyIn274 :: (Located RdrName) -> (HappyAbsSyn )+happyIn274 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn274 #-}+happyOut274 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut274 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut274 #-}+happyIn275 :: (Located RdrName) -> (HappyAbsSyn )+happyIn275 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn275 #-}+happyOut275 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut275 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut275 #-}+happyIn276 :: (Located RdrName) -> (HappyAbsSyn )+happyIn276 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn276 #-}+happyOut276 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut276 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut276 #-}+happyIn277 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn277 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn277 #-}+happyOut277 :: (HappyAbsSyn ) -> (LHsType GhcPs)+happyOut277 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut277 #-}+happyIn278 :: (Located RdrName) -> (HappyAbsSyn )+happyIn278 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn278 #-}+happyOut278 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut278 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut278 #-}+happyIn279 :: (Located RdrName) -> (HappyAbsSyn )+happyIn279 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn279 #-}+happyOut279 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut279 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut279 #-}+happyIn280 :: (Located RdrName) -> (HappyAbsSyn )+happyIn280 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn280 #-}+happyOut280 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut280 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut280 #-}+happyIn281 :: (Located RdrName) -> (HappyAbsSyn )+happyIn281 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn281 #-}+happyOut281 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut281 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut281 #-}+happyIn282 :: (Located RdrName) -> (HappyAbsSyn )+happyIn282 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn282 #-}+happyOut282 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut282 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut282 #-}+happyIn283 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn283 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn283 #-}+happyOut283 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut283 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut283 #-}+happyIn284 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn284 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn284 #-}+happyOut284 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut284 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut284 #-}+happyIn285 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn285 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn285 #-}+happyOut285 :: (HappyAbsSyn ) -> (LHsExpr GhcPs)+happyOut285 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut285 #-}+happyIn286 :: (Located RdrName) -> (HappyAbsSyn )+happyIn286 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn286 #-}+happyOut286 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut286 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut286 #-}+happyIn287 :: (Located RdrName) -> (HappyAbsSyn )+happyIn287 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn287 #-}+happyOut287 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut287 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut287 #-}+happyIn288 :: (Located RdrName) -> (HappyAbsSyn )+happyIn288 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn288 #-}+happyOut288 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut288 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut288 #-}+happyIn289 :: (Located RdrName) -> (HappyAbsSyn )+happyIn289 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn289 #-}+happyOut289 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut289 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut289 #-}+happyIn290 :: (Located RdrName) -> (HappyAbsSyn )+happyIn290 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn290 #-}+happyOut290 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut290 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut290 #-}+happyIn291 :: (Located RdrName) -> (HappyAbsSyn )+happyIn291 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn291 #-}+happyOut291 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut291 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut291 #-}+happyIn292 :: (Located RdrName) -> (HappyAbsSyn )+happyIn292 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn292 #-}+happyOut292 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut292 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut292 #-}+happyIn293 :: (Located RdrName) -> (HappyAbsSyn )+happyIn293 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn293 #-}+happyOut293 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut293 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut293 #-}+happyIn294 :: (Located RdrName) -> (HappyAbsSyn )+happyIn294 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn294 #-}+happyOut294 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut294 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut294 #-}+happyIn295 :: (Located RdrName) -> (HappyAbsSyn )+happyIn295 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn295 #-}+happyOut295 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut295 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut295 #-}+happyIn296 :: (Located RdrName) -> (HappyAbsSyn )+happyIn296 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn296 #-}+happyOut296 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut296 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut296 #-}+happyIn297 :: (Located RdrName) -> (HappyAbsSyn )+happyIn297 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn297 #-}+happyOut297 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut297 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut297 #-}+happyIn298 :: (Located RdrName) -> (HappyAbsSyn )+happyIn298 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn298 #-}+happyOut298 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut298 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut298 #-}+happyIn299 :: (Located RdrName) -> (HappyAbsSyn )+happyIn299 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn299 #-}+happyOut299 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut299 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut299 #-}+happyIn300 :: (Located FastString) -> (HappyAbsSyn )+happyIn300 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn300 #-}+happyOut300 :: (HappyAbsSyn ) -> (Located FastString)+happyOut300 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut300 #-}+happyIn301 :: (Located FastString) -> (HappyAbsSyn )+happyIn301 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn301 #-}+happyOut301 :: (HappyAbsSyn ) -> (Located FastString)+happyOut301 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut301 #-}+happyIn302 :: (Located RdrName) -> (HappyAbsSyn )+happyIn302 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn302 #-}+happyOut302 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut302 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut302 #-}+happyIn303 :: (Located RdrName) -> (HappyAbsSyn )+happyIn303 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn303 #-}+happyOut303 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut303 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut303 #-}+happyIn304 :: (Located RdrName) -> (HappyAbsSyn )+happyIn304 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn304 #-}+happyOut304 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut304 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut304 #-}+happyIn305 :: (Located RdrName) -> (HappyAbsSyn )+happyIn305 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn305 #-}+happyOut305 :: (HappyAbsSyn ) -> (Located RdrName)+happyOut305 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut305 #-}+happyIn306 :: (Located (HsLit GhcPs)) -> (HappyAbsSyn )+happyIn306 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn306 #-}+happyOut306 :: (HappyAbsSyn ) -> (Located (HsLit GhcPs))+happyOut306 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut306 #-}+happyIn307 :: (()) -> (HappyAbsSyn )+happyIn307 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn307 #-}+happyOut307 :: (HappyAbsSyn ) -> (())+happyOut307 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut307 #-}+happyIn308 :: (Located ModuleName) -> (HappyAbsSyn )+happyIn308 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn308 #-}+happyOut308 :: (HappyAbsSyn ) -> (Located ModuleName)+happyOut308 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut308 #-}+happyIn309 :: (([SrcSpan],Int)) -> (HappyAbsSyn )+happyIn309 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn309 #-}+happyOut309 :: (HappyAbsSyn ) -> (([SrcSpan],Int))+happyOut309 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut309 #-}+happyIn310 :: (([SrcSpan],Int)) -> (HappyAbsSyn )+happyIn310 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn310 #-}+happyOut310 :: (HappyAbsSyn ) -> (([SrcSpan],Int))+happyOut310 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut310 #-}+happyIn311 :: (([SrcSpan],Int)) -> (HappyAbsSyn )+happyIn311 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn311 #-}+happyOut311 :: (HappyAbsSyn ) -> (([SrcSpan],Int))+happyOut311 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut311 #-}+happyIn312 :: (LHsDocString) -> (HappyAbsSyn )+happyIn312 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn312 #-}+happyOut312 :: (HappyAbsSyn ) -> (LHsDocString)+happyOut312 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut312 #-}+happyIn313 :: (LHsDocString) -> (HappyAbsSyn )+happyIn313 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn313 #-}+happyOut313 :: (HappyAbsSyn ) -> (LHsDocString)+happyOut313 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut313 #-}+happyIn314 :: (Located (String, HsDocString)) -> (HappyAbsSyn )+happyIn314 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn314 #-}+happyOut314 :: (HappyAbsSyn ) -> (Located (String, HsDocString))+happyOut314 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut314 #-}+happyIn315 :: (Located (Int, HsDocString)) -> (HappyAbsSyn )+happyIn315 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn315 #-}+happyOut315 :: (HappyAbsSyn ) -> (Located (Int, HsDocString))+happyOut315 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut315 #-}+happyIn316 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn316 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn316 #-}+happyOut316 :: (HappyAbsSyn ) -> (Maybe LHsDocString)+happyOut316 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut316 #-}+happyIn317 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn317 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn317 #-}+happyOut317 :: (HappyAbsSyn ) -> (Maybe LHsDocString)+happyOut317 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut317 #-}+happyIn318 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn318 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn318 #-}+happyOut318 :: (HappyAbsSyn ) -> (Maybe LHsDocString)+happyOut318 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut318 #-}+happyInTok :: ((Located Token)) -> (HappyAbsSyn )+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn ) -> ((Located Token))+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOutTok #-}+++happyExpList :: HappyAddr+happyExpList = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x0d\x44\xf4\xff\x1f\x3f\x38\x00\x00\x04\x19\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x9b\xaf\xfa\xff\x2f\xff\xfb\xf9\x20\x08\x32\x00\x55\xe1\xcc\xff\xff\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x10\x24\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xbf\xf8\xc1\x01\x00\x20\xc8\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x5c\x44\xff\x7f\xf9\x9f\x03\x04\x41\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x88\xfe\xff\xe3\x07\x07\x00\x80\x20\x03\x50\x15\xce\xfc\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x10\xfd\xfe\x84\x0f\x00\x00\x20\x00\x86\x20\x0a\xfa\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x9e\x01\x00\x18\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\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\x10\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\x20\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\x82\x1f\x9f\xf0\x01\x18\x00\x00\x88\x40\x54\x81\x23\x18\x00\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xc1\x8f\x4f\xf8\x00\x0c\x00\x00\x04\x20\xaa\xc0\x11\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x82\x1f\x9f\xf0\x01\x00\x00\x00\x00\x00\x40\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x1f\x80\x01\x40\x80\x0c\xc5\x15\xfc\x9e\x01\x00\x18\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\x06\x04\x40\xf4\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2e\xf8\x3d\x03\x00\x30\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\x0c\x08\x80\xe8\xc7\x27\x7c\x00\x06\x00\x81\x36\x14\x75\xf8\x7b\x06\x00\x60\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\x8f\x4f\xf8\x00\x0c\x00\x02\x64\x28\xaa\xf1\xf7\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x82\x1f\x9f\xf0\x01\x00\x00\x00\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x08\x80\x21\x88\x82\x5e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x00\x04\x09\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x18\x02\x10\x84\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\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\x00\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x00\x41\x02\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x06\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x01\x84\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x28\x12\x10\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x01\x01\x10\xfd\xfe\x84\x0f\x00\x00\x00\x40\x00\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x20\x44\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\xa2\xdf\x9f\xf0\x01\x00\x00\x00\x08\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xf1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x88\x7e\x7f\xc2\x07\x00\x00\x00\x20\x00\x50\x15\xce\xfc\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x20\x41\x86\xe0\x2a\xfe\xff\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x40\x82\x0c\x41\x55\xfc\xff\xff\xf0\xfa\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\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x80\x14\x19\x82\xba\xfc\xff\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x29\x32\x04\xd5\xf9\xff\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\xa2\xdf\x9f\xf0\x01\x00\x00\x00\x00\x00\x44\x01\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x00\x04\x09\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x08\x80\xe8\xc7\x27\x7c\x00\x06\x00\x01\x32\x14\x55\xf0\x7b\x06\x00\x60\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xbf\xf8\xc1\x01\x00\x20\x48\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x88\xfe\xff\xe2\x07\x07\x00\x80\x20\x01\x50\x15\xce\xfc\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x04\x04\x40\xf0\xe3\x13\x3e\x00\x00\x00\x00\x00\x80\x2a\x60\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\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\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\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x00\x00\x08\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x80\xe8\xf7\x27\x7c\x00\x00\x00\x00\x00\x00\x51\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xbf\xf8\xc1\x01\x00\xa4\xc8\x10\xd4\xe5\xff\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xfe\x84\x0f\x00\x00\x00\x40\x00\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x43\x00\x00\x31\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xc1\x8f\x4f\xf8\x00\x0c\x00\x02\x64\x28\xaa\xe0\x77\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x42\xf0\xfb\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x1d\x03\x00\x30\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\x20\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\xa2\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x88\x02\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\x80\x80\x00\x88\x7e\x7f\xc2\x07\x00\x00\x00\x00\x00\x10\x05\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x52\xfd\xfe\x84\x0f\x00\x00\x00\x00\x00\x20\x0a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x02\xa0\xfa\xfd\x09\x1f\x00\x00\x00\x00\x00\x00\x04\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x80\xe8\xf7\x27\x7c\x00\x00\x00\x00\x00\x00\x10\x40\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\x18\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x04\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x05\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xfe\x84\x0f\x00\x00\x00\x40\x00\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x86\x00\x04\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x20\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x80\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x82\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\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\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\x82\x1f\x9f\xf0\x01\x18\x00\x04\xc8\x50\x54\xc1\xef\x18\x00\x80\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\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x9e\x01\x00\x18\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\x06\x04\x40\xf0\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x1d\x03\x00\x30\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0a\x00\x00\x41\x02\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x08\x80\xe8\xc7\x27\x7c\x00\x06\x00\x01\x32\x14\x55\xf0\x7b\x06\x00\x60\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\x00\x80\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\x30\x20\x00\x82\x1f\x9f\xf0\x01\x18\x00\x04\xc8\x50\x54\xc1\xef\x18\x00\x80\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\xf8\x03\x00\x88\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\x20\x00\x00\x20\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\xca\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x88\xfe\xff\xe2\x07\x07\x00\x90\x22\x43\x50\x15\xff\xff\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xfd\x89\x1f\x00\x00\x00\x80\x00\x40\x55\x38\xf3\xff\xf0\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\x00\x80\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\xa2\xdf\x9f\xf0\x01\x00\x00\x04\xc0\x10\xc4\x21\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x88\x7e\x7f\xc2\x07\x00\x00\x00\x00\x00\x00\x01\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x00\x00\x08\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x08\x80\xe8\xc7\x27\x7c\x00\x06\x00\x01\x32\x14\x55\xf0\x7b\x06\x00\x60\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\x20\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\xb9\x88\xfe\xff\xf2\x3f\x07\x08\x82\x20\x03\x50\x15\xce\xfc\xff\xbf\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x73\x11\xfd\xff\xe5\x7f\x0e\x10\x04\x41\x06\xa0\x2a\x9c\xf9\xff\x7f\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x02\x20\xfa\xfd\x09\x1f\x00\x00\x00\x00\x00\x00\x04\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x40\xf4\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x3d\x03\x00\x30\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\x01\x30\x04\x00\x10\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x0b\x00\x10\x84\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\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\x04\x00\x10\x33\x00\x00\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x43\x00\x82\x30\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x40\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\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\xca\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xfd\x09\x1f\x00\x00\x00\x80\x00\x42\x55\x38\xf3\xff\xf0\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x44\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x10\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xff\xf8\xc1\x01\x00\x20\xc8\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\xff\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x01\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x01\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x08\x12\x00\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x01\x00\x00\x20\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x00\x10\x81\xa8\x02\x47\x30\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x06\x04\x40\xf4\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x3d\x03\x00\x30\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\x1c\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x08\x12\x00\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x10\x24\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xbf\xf8\xc1\x01\x00\x20\x48\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x88\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x87\xbf\x67\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x10\xfd\xfe\x84\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\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\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x88\x7e\x7f\xc2\x07\x00\x00\x00\x00\x00\x00\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x80\xe0\xc7\x27\x7c\x00\x00\x00\x00\x00\x00\x10\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x82\x1f\x9f\xf0\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x9e\x01\x00\x18\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x00\x00\xa2\x80\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x08\x0e\x7c\xc2\x07\x00\x00\x00\x00\x00\x00\x00\x0c\x20\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x88\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x67\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x02\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\x8f\x4f\xf8\x00\x0c\x00\x02\x64\x28\xaa\xe0\xf7\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\xa2\x1f\x9f\xf0\x01\x18\x00\x04\xc8\x50\x54\xc1\xef\x19\x00\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xbf\xf8\xc1\x01\x00\x20\x48\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x00\x04\x09\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x00\x41\x06\xa4\xaa\x9c\xf9\x7f\x78\xfd\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\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x0c\x60\x55\x39\xf3\xff\xf0\xfa\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\x06\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x11\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x12\x64\x08\xaa\xe2\xff\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x98\xfe\xff\xe2\x07\x07\x00\x80\x20\x03\x50\x15\xce\xfc\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x20\x41\x86\xa0\x2a\xfe\xff\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x00\x04\x09\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1a\x88\xe9\xff\x2f\x7e\x70\x00\x00\x08\x32\x00\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x12\x64\x08\xaa\xe2\xff\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x80\x04\x19\x82\xaa\xfc\xff\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\xa2\xdf\x9f\xf0\x01\x00\x00\x00\x00\x00\x54\x8d\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xcd\x57\xfd\xff\x97\xff\xfd\x7c\x10\x04\x19\x80\xaa\x70\xe6\xff\xff\xf5\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x20\xf8\xf1\x09\x1f\x00\x00\x00\x00\x00\x00\x04\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x04\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x80\x21\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\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\x40\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x10\xfd\xfe\x84\x0f\x00\x00\x00\x00\x00\x20\x0a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x20\xfa\xfd\x09\x1f\x00\x00\x00\x00\x00\x40\x14\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\x04\x00\x10\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x40\x90\x00\xa8\x0a\x67\xfe\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x88\xfe\xff\xe2\x07\x07\x00\x90\x20\x43\x50\x15\xff\xff\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xf8\xf1\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x8e\x01\x00\x18\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\x01\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x08\x7e\x7c\xc2\x07\x00\x00\x00\x00\x00\x00\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x10\x24\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xbf\xf8\xc1\x01\x00\x20\xc8\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x09\x00\x00\x80\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x88\x7e\x7f\xc2\x07\x00\x00\x00\x00\x00\x00\x01\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\xa2\xdf\x9f\xf0\x01\x00\x00\x00\x00\x00\x40\x00\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x80\xe8\xf7\x27\x7c\x00\x00\x00\x00\x00\x00\x10\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x10\x64\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xbf\xf8\xc1\x01\x00\x20\xc8\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x88\x7e\x7f\xc2\x07\x00\x00\x00\x00\x00\x10\x05\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x10\xfd\xfe\x84\x0f\x00\x00\x00\x00\x00\x20\x0a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x80\xe8\xf7\x27\x7c\x00\x00\x00\x00\x00\x00\x51\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\xef\x4f\xf8\x00\x00\x00\x00\x04\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xe6\xab\xfe\xff\xcb\xff\x7e\x3e\x08\x82\x0c\x40\x55\x38\xf3\xff\xff\xfa\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\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\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x15\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x01\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x04\x04\x40\xf4\xfb\x13\x3e\x00\x00\x00\x00\x00\x00\x08\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x80\xe8\xf7\x27\x7c\x00\x00\x00\x00\x00\x00\x10\x40\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x20\xfa\xfd\x09\x1f\x00\x00\x00\x00\x00\x00\x04\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\x8f\x4f\xf8\x00\x0c\x00\x02\x64\x28\xaa\xe0\xf7\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x08\x7e\x7c\xc2\x07\x00\x00\x00\x00\x00\x00\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x88\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x67\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x40\xf4\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x3d\x03\x00\x30\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x82\x1f\x9f\xf0\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x08\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x63\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x9e\x01\x00\x18\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\x06\x04\x40\xf4\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x3d\x03\x00\x30\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\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\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x88\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x67\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x40\xf4\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x3d\x03\x00\x30\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x73\x11\xfd\xff\xe5\x7f\x0e\x10\x04\x41\x06\xa0\x2a\x9c\xf9\xff\x7f\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\x8f\x4f\xf8\x00\x0c\x00\x02\x64\x28\xaa\xe0\xf7\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\xa2\xdf\x9f\xf0\x01\x00\x00\x00\x00\x00\x40\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x08\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x63\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x9e\x01\x00\x18\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\x80\x00\x18\x02\x00\x88\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x00\x04\x09\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x00\x41\x02\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x88\xfe\xff\xe2\x07\x07\x00\x80\x20\x03\x50\x55\xce\xfc\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x68\x20\xa2\xff\xff\xf8\xc1\x01\x00\x20\xc8\x00\x54\x85\x33\xff\x0f\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x0e\x0d\x44\xf4\xff\x17\x3f\x38\x00\x00\x04\x19\x80\xaa\x70\xe6\xff\xe1\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x08\x12\x00\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd0\x40\x44\xff\x7f\xf1\x83\x03\x00\x48\x90\x21\xa8\x8a\xff\xff\x1f\x5e\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x88\x7e\x7f\xc2\x07\x00\x00\x08\x00\x00\x00\x01\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x08\x80\xe8\xc7\x27\x7c\x00\x06\x00\x01\x32\x14\x55\xf0\x7b\x06\x00\x60\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\xa2\x1f\x9f\xf0\x01\x18\x00\x04\xc8\x50\x54\xc1\xef\x19\x00\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x88\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x67\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x10\x1c\xf8\x84\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x00\x41\x02\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x0c\x40\x55\x38\xf3\xff\xf0\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x10\x24\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x98\xfe\xff\xe2\x07\x07\x00\x80\x20\x03\x50\x15\xce\xfc\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x31\xfd\xff\xc5\x0f\x0e\x00\x00\x41\x06\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\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\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x08\x12\x00\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x6b\x2e\xaa\xff\xbf\xfc\xcf\x01\x82\x20\xc8\x00\x54\x85\x33\xff\xff\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd6\x5c\x54\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x69\xae\xaa\xff\xbf\xfc\xcf\x01\x82\x20\xc8\x00\x54\x85\x33\xff\xff\xaf\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xd2\x5c\x55\xff\x7f\xf9\x9f\x03\x04\x41\x90\x01\xa8\x0a\x67\xfe\xff\x5f\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x80\xe0\xc7\x27\x7c\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x20\xfa\xfd\x09\x1f\x00\x00\x00\x00\x00\x00\x04\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x44\xbf\x3f\xe1\x03\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x10\xfd\xfe\x84\x0f\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x01\x00\xc4\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xe0\x00\x00\x10\x24\x00\xaa\xc2\x99\xff\x87\xd7\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x73\x11\xfd\xff\xe5\x7f\x0e\x10\x04\x41\x06\xa0\x2a\x9c\xf9\xff\x7f\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\xe6\x22\xfa\xff\xcb\xff\x1c\x20\x08\x82\x0c\x40\x55\x38\xf3\xff\xff\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\x8f\x4f\xf8\x00\x0c\x00\x02\x64\x28\xaa\xe0\xf7\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x40\xf0\xe3\x13\x3e\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x00\x41\x02\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x21\xf8\xf5\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x8e\x01\x00\x18\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\x10\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x04\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x05\x08\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x40\xf4\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x3d\x03\x00\x30\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xa1\x81\x88\xfe\xff\xe2\x07\x07\x00\x80\x20\x01\x50\x15\xce\xfc\x3f\xbc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x43\x03\x11\xfd\xff\xc5\x0f\x0e\x00\x00\x41\x02\xa0\x2a\x9c\xf9\x7f\x78\xfd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x1f\x1c\x00\x00\x82\x04\x40\x55\x38\xf3\xff\xf0\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x08\x0e\x7c\xc2\x07\x00\x00\x00\x00\x00\x00\x00\x0c\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x20\xd5\xef\x4f\xfa\x00\x00\x00\x00\x00\x00\x20\x90\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\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x20\x43\x00\x00\x30\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\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x08\x0e\x7c\xc2\x07\x00\x00\x00\x00\x00\x00\x00\x0c\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x08\x12\x00\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x40\xf0\xe3\x13\x3e\x00\x03\x00\x00\x11\x88\x2a\x70\x04\x03\x00\x30\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\x08\x08\x80\xe0\xc7\x27\x7c\x00\x00\x00\x00\x00\x00\x10\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x08\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x07\xbf\x63\x00\x00\xc6\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xad\xb9\xa8\xfe\xff\xf2\x3f\x07\x08\x82\x20\x03\x50\x15\xce\xfc\xff\xbf\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x04\x40\xf0\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x1d\x03\x00\x30\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\x0c\x08\x80\xe0\xc7\x27\x7c\x00\x06\x00\x01\x32\x14\x55\xf0\x3b\x06\x00\x60\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x60\x08\x00\x20\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\x82\x1f\x9f\xf0\x01\x18\x00\x04\xc8\x50\x54\xc1\xef\x18\x00\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\xe6\xaa\xfa\xff\xcb\xff\x1c\x20\x08\x82\x0c\x40\x55\x38\xf3\xff\xff\xfa\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\x06\x04\x40\xf0\xe3\x13\x3e\x00\x03\x80\x00\x19\x8a\x2a\xf8\x1d\x03\x00\x30\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\x82\x1f\x9f\xf0\x01\x18\x00\x04\xc8\x50\x54\xc1\xef\x18\x00\x80\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfc\xf8\x84\x0f\xc0\x00\x30\x40\x86\xa2\x0a\x7e\xc7\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xf8\xf1\x09\x1f\x80\x01\x60\x80\x0c\x45\x15\xfc\x8e\x01\x00\x18\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\x04\x04\x40\xf0\xe3\x13\x3e\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x44\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x33\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x10\xfc\xf8\x84\x0f\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x08\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x63\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\x8f\x4f\xf8\x00\x0c\x00\x02\x64\x28\xaa\xe0\xf7\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfd\xf8\x84\x0f\xc0\x00\x20\x40\x86\xa2\x0a\x7e\xcf\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x1f\x80\x01\x40\x80\x0c\x45\x15\xfc\x9e\x01\x00\x18\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\xa2\x1f\x9f\xf0\x01\x18\x00\x04\xc8\x50\x54\xc1\xef\x19\x00\x80\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\x88\x02\x04\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x01\x10\xfc\xf8\x84\x0f\xc0\x00\x20\x40\x04\xa2\x0a\x5e\xc1\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1c\x1a\x88\xe8\xff\x2f\x7e\x70\x00\x00\x08\x12\x00\x55\xe1\xcc\xff\xc3\xeb\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x20\x08\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\xa8\x7e\x7f\xc2\x07\x00\x00\x08\x00\x00\x00\x01\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xf8\xf1\x09\x1f\x80\x01\x00\x80\x08\x44\x15\x38\x82\x01\x00\x18\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\x06\x04\x40\xf0\xe3\x13\x3e\x00\x03\x00\x00\x11\x88\x2a\x70\x04\x03\x00\x30\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x40\x00\x04\x3f\x3e\xe1\x03\x30\x00\x08\x90\xa1\xa8\x82\xdf\x31\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x10\x00\xd1\x8f\x4f\xf8\x00\x0c\x00\x02\x6d\x28\xea\xf0\xf7\x0c\x00\xc0\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x08\x7e\x7c\xc2\x07\x00\x00\x00\x00\x00\x00\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x80\x00\x08\x7e\x7c\xc2\x07\x60\x00\x10\x20\x43\x51\x05\xbf\x63\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x10\xfc\xf8\x84\x0f\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x08\x80\xe0\xc7\x27\x7c\x00\x06\x00\x01\x22\x10\x55\xf0\x0a\x06\x00\x60\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x20\x00\x82\x1f\x9f\xf0\x01\x18\x00\x00\x88\x40\x54\x81\x23\x18\x00\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x20\x38\xf0\x09\x1f\x00\x00\x00\x00\x00\x00\x00\x70\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x50\xfd\xfe\x84\x0f\x00\x00\x10\x00\x00\x00\x02\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\x90\xea\xf7\x27\x7d\x00\x00\x00\x00\x00\x00\x10\xc0\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++{-# NOINLINE happyExpListPerState #-}+happyExpListPerState st =+ token_strs_expected+ where token_strs = ["error","%dummy","%start_parseModule","%start_parseSignature","%start_parseImport","%start_parseStatement","%start_parseDeclaration","%start_parseExpression","%start_parsePattern","%start_parseTypeSignature","%start_parseStmt","%start_parseIdentifier","%start_parseType","%start_parseBackpack","%start_parseHeader","identifier","backpack","units","unit","unitid","msubsts","msubst","moduleid","pkgname","litpkgname_segment","litpkgname","mayberns","rns","rn","unitbody","unitdecls","unitdecl","signature","module","maybedocheader","missing_module_keyword","implicit_top","maybemodwarning","body","body2","top","top1","header","header_body","header_body2","header_top","header_top_importdecls","maybeexports","exportlist","exportlist1","expdoclist","exp_doc","export","export_subspec","qcnames","qcnames1","qcname_ext_w_wildcard","qcname_ext","qcname","semis1","semis","importdecls","importdecls_semi","importdecl","maybe_src","maybe_safe","maybe_pkg","optqualified","maybeas","maybeimpspec","impspec","prec","infix","ops","topdecls","topdecls_semi","topdecl","cl_decl","ty_decl","inst_decl","overlap_pragma","deriv_strategy","opt_injective_info","injectivity_cond","inj_varids","where_type_family","ty_fam_inst_eqn_list","ty_fam_inst_eqns","ty_fam_inst_eqn","at_decl_cls","opt_family","opt_instance","at_decl_inst","data_or_newtype","opt_kind_sig","opt_datafam_kind_sig","opt_tyfam_kind_sig","opt_at_kind_inj_sig","tycl_hdr","capi_ctype","stand_alone_deriving","role_annot","maybe_roles","roles","role","pattern_synonym_decl","pattern_synonym_lhs","vars0","cvars1","where_decls","pattern_synonym_sig","decl_cls","decls_cls","decllist_cls","where_cls","decl_inst","decls_inst","decllist_inst","where_inst","decls","decllist","binds","wherebinds","rules","rule","rule_activation","rule_explicit_activation","rule_forall","rule_var_list","rule_var","warnings","warning","deprecations","deprecation","strings","stringlist","annotation","fdecl","callconv","safety","fspec","opt_sig","opt_tyconsig","sigtype","sigtypedoc","sig_vars","sigtypes1","strict_mark","strictness","unpackedness","ctype","ctypedoc","context","context_no_ops","type","typedoc","btype","btype_no_ops","tyapps","tyapp","atype","inst_type","deriv_types","comma_types0","comma_types1","bar_types2","tv_bndrs","tv_bndr","fds","fds1","fd","varids0","kind","gadt_constrlist","gadt_constrs","gadt_constr_with_doc","gadt_constr","constrs","constrs1","constr","forall","constr_stuff","fielddecls","fielddecls1","fielddecl","maybe_derivings","derivings","deriving","docdecl","docdecld","decl_no_th","decl","rhs","gdrhs","gdrh","sigdecl","activation","explicit_activation","quasiquote","exp","infixexp","infixexp_top","exp10_top","exp10","optSemi","scc_annot","hpc_annot","fexp","aexp","aexp1","aexp2","splice_exp","cmdargs","acmd","cvtopbody","cvtopdecls0","texp","tup_exprs","commas_tup_tail","tup_tail","list","lexps","flattenedpquals","pquals","squals","transformqual","parr","guardquals","guardquals1","altslist","alts","alts1","alt","alt_rhs","ralt","gdpats","ifgdpats","gdpat","pat","bindpat","apat","apats","stmtlist","stmts","maybe_stmt","stmt","qual","fbinds","fbinds1","fbind","dbinds","dbind","ipvar","overloaded_label","name_boolformula_opt","name_boolformula","name_boolformula_and","name_boolformula_and_list","name_boolformula_atom","namelist","name_var","qcon_nowiredlist","qcon","gen_qcon","con","con_list","sysdcon_nolist","sysdcon","conop","qconop","gtycon","ntgtycon","oqtycon","oqtycon_no_varcon","qtyconop","qtycon","qtycondoc","tycon","qtyconsym","tyconsym","op","varop","qop","qopm","hole_op","qvarop","qvaropm","tyvar","tyvarop","tyvarid","var","qvar","qvarid","varid","qvarsym","qvarsym_no_minus","qvarsym1","varsym","varsym_no_minus","special_id","special_sym","qconid","conid","qconsym","consym","literal","close","modid","commas","bars0","bars","docnext","docprev","docnamed","docsection","moduleheader","maybe_docprev","maybe_docnext","'_'","'as'","'case'","'class'","'data'","'default'","'deriving'","'do'","'else'","'hiding'","'if'","'import'","'in'","'infix'","'infixl'","'infixr'","'instance'","'let'","'module'","'newtype'","'of'","'qualified'","'then'","'type'","'where'","'forall'","'foreign'","'export'","'label'","'dynamic'","'safe'","'interruptible'","'unsafe'","'mdo'","'family'","'role'","'stdcall'","'ccall'","'capi'","'prim'","'javascript'","'proc'","'rec'","'group'","'by'","'using'","'pattern'","'static'","'stock'","'anyclass'","'unit'","'signature'","'dependency'","'{-# INLINE'","'{-# SPECIALISE'","'{-# SPECIALISE_INLINE'","'{-# SOURCE'","'{-# RULES'","'{-# CORE'","'{-# SCC'","'{-# GENERATED'","'{-# DEPRECATED'","'{-# WARNING'","'{-# UNPACK'","'{-# NOUNPACK'","'{-# ANN'","'{-# VECTORISE'","'{-# VECTORISE_SCALAR'","'{-# NOVECTORISE'","'{-# MINIMAL'","'{-# CTYPE'","'{-# OVERLAPPING'","'{-# OVERLAPPABLE'","'{-# OVERLAPS'","'{-# INCOHERENT'","'{-# COMPLETE'","'#-}'","'..'","':'","'::'","'='","'\\\\'","'lcase'","'|'","'<-'","'->'","'@'","'~'","'~#'","'=>'","'-'","'!'","'-<'","'>-'","'-<<'","'>>-'","'.'","TYPEAPP","'{'","'}'","vocurly","vccurly","'['","']'","'[:'","':]'","'('","')'","'(#'","'#)'","'(|'","'|)'","';'","','","'`'","SIMPLEQUOTE","VARID","CONID","VARSYM","CONSYM","QVARID","QCONID","QVARSYM","QCONSYM","IPDUPVARID","LABELVARID","CHAR","STRING","INTEGER","RATIONAL","PRIMCHAR","PRIMSTRING","PRIMINTEGER","PRIMWORD","PRIMFLOAT","PRIMDOUBLE","DOCNEXT","DOCPREV","DOCNAMED","DOCSECTION","'[|'","'[p|'","'[t|'","'[d|'","'|]'","'[||'","'||]'","TH_ID_SPLICE","'$('","TH_ID_TY_SPLICE","'$$('","TH_TY_QUOTE","TH_QUASIQUOTE","TH_QQUASIQUOTE","%eof"]+ bit_start = st * 473+ bit_end = (st + 1) * 473+ read_bit = readArrayBit happyExpList+ bits = map read_bit [bit_start..bit_end - 1]+ bits_indexed = zip bits [0..472]+ token_strs_expected = concatMap f bits_indexed+ f (False, _) = []+ f (True, nr) = [token_strs !! nr]++happyActOffsets :: HappyAddr+happyActOffsets = HappyA# "\x4f\x00\x0c\x00\xa8\x00\x18\x19\xde\x0e\xd9\x20\xd7\x1d\x7c\x15\x18\x19\x73\x3f\x07\x2b\xc8\x00\x41\x00\x3b\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x03\x00\x00\x00\x00\x66\x00\x00\x00\x6d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x71\x01\x0d\x02\x0d\x02\x21\x38\x00\x00\x55\x02\xb6\x01\x02\x02\x00\x00\x0d\x03\x9e\x36\x00\x00\x00\x00\x00\x00\x2e\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\x99\x46\x00\x00\x00\x00\x00\x00\x34\x02\x4c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x84\x29\x05\x2a\x01\x28\x82\x28\x7c\x42\xda\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x20\x00\x00\x00\x00\x56\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x02\x87\x0a\x25\x03\xda\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x02\xcf\x0a\x00\x00\x00\x00\xd9\x20\xd9\x20\xb9\x23\x00\x00\xae\x02\x00\x00\x00\x00\xc4\x02\x87\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x00\x00\xd9\x20\xff\x00\xb2\x19\x35\x03\x63\x03\xdd\x25\x63\x03\xdd\x25\xbc\x02\x18\x00\xbf\x02\x30\x23\xdd\x25\x42\x24\xdd\x25\x16\x16\xe4\x17\x7a\x12\x14\x13\x78\x27\xf2\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x20\xd9\x20\x07\x2b\xfc\x03\xd9\x20\x00\x00\xd9\x20\x00\x00\xd9\x20\xfa\x41\xd6\x02\x00\x00\xc1\x02\x42\x03\x00\x00\xfd\x02\x09\x03\x00\x00\x00\x00\x00\x00\x20\x04\x6d\x03\x20\x03\x59\x00\x20\x03\x3b\x43\xe1\x43\x6d\x03\xae\x13\x00\x00\xf5\x02\xdd\x25\xf5\x02\xf5\x02\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x36\x91\x03\x3f\x03\xd4\x01\xc3\x04\x00\x00\x86\x2a\x90\x01\x3f\x44\x4d\x03\x5f\x44\x5f\x44\xc1\x43\xdd\x42\xb8\x03\x3b\x43\xdd\x25\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x03\x3e\x03\xa9\x03\x6b\x03\xc6\x03\x73\x03\x0b\x04\x00\x00\x00\x00\x00\x00\xc1\x03\xba\x03\x50\x00\x08\x03\x08\x03\x29\x04\x06\x04\x8b\x00\x0d\x04\x23\x05\x1c\x04\x23\x05\x23\x05\xdd\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x25\x16\x04\x57\x03\x42\x00\x00\x00\x66\x01\x2d\x04\xa2\x00\x00\x00\x66\x01\xb4\x00\x00\x00\x2b\x04\xd3\x03\x67\x45\x52\x04\x44\x00\x44\x01\x00\x00\x86\x06\x86\x06\x58\x04\x5b\x04\x9e\x36\x9e\x36\xeb\x02\x07\x2b\x95\x04\xac\x04\xd1\x04\xec\x04\xee\x04\x00\x00\x00\x00\x00\x00\x07\x2b\x9e\x36\xe2\x04\xef\x04\x00\x00\x8b\x00\x00\x00\xa7\x22\x00\x00\x00\x00\x88\x2b\x41\x40\x9e\x36\xfc\x04\xd8\x04\x00\x00\x0d\x05\xcf\x0a\xee\x01\x01\x05\x00\x00\xd9\x20\x00\x00\x00\x00\x00\x00\x0b\x05\x12\x05\x2e\x05\x3a\x05\x48\x14\xb0\x16\x00\x00\x42\x24\x00\x00\x00\x00\x41\x40\x53\x05\x5f\x05\x83\x05\x00\x00\x62\x05\x00\x00\x65\x05\x00\x00\x5b\x43\x45\x00\x3b\x43\x00\x00\x0f\x00\x3b\x43\x09\x2c\x3b\x43\x00\x00\xde\x05\xe0\x11\xe0\x11\xc1\x45\x8a\x2c\x24\x09\x00\x00\x00\x00\x00\x00\x00\x00\x92\x05\xa1\x05\x48\x0b\x93\x03\xa2\x05\xa8\x05\x88\x05\x8d\x05\x00\x00\x00\x00\x90\x05\xd2\x06\xa3\x05\x00\x00\x00\x00\xb4\x02\x00\x00\x00\x00\x54\x01\xd3\x05\x00\x00\x00\x00\xe2\x14\x00\x00\xdb\x05\x86\x01\xd9\x05\x00\x06\x95\x01\x14\x06\x21\x06\x00\x00\x00\x00\xcb\x24\x00\x00\x00\x00\x54\x25\x68\x04\xdd\x25\x07\x06\x47\x06\x4a\x06\x4e\x06\x00\x00\x00\x00\x4c\x1a\x4c\x1a\x49\x06\x00\x00\x93\x06\x34\x06\x5d\x00\x00\x00\x00\x00\x71\x1e\x5f\x06\x00\x00\xa1\x06\xdd\x25\xd9\x20\xfd\x42\x00\x00\x21\x38\x00\x00\x00\x00\xd9\x20\x0b\x2d\xd9\x20\xd9\x20\xd9\x20\xd9\x20\x44\x06\x57\x06\xcc\x03\x50\x06\x51\x06\x79\x02\x62\x06\x6e\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x2d\x03\x29\x5c\x42\x69\x06\x6a\x06\x73\x01\x70\x06\x72\x06\xdd\x03\x00\x00\xd3\x01\x77\x06\xdb\x02\x78\x06\x7a\x06\x7b\x06\x00\x00\x7e\x06\x00\x00\x20\x02\x00\x00\x85\x06\x00\x00\x4d\x00\x00\x00\xc1\x45\x00\x00\x00\x00\x89\x06\x99\x46\x00\x00\x2f\x47\x9e\x36\x00\x00\x0b\x2d\x0b\x2d\x00\x00\x00\x00\x78\x41\x13\x02\x00\x00\xd6\x3e\x06\x01\x00\x00\x82\x06\x00\x00\xf5\x03\xf5\x03\xab\x03\x00\x00\x00\x00\xab\x03\x00\x00\x00\x00\xe8\x06\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x06\xdf\x06\xa0\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x06\x00\x00\x0b\x2d\x17\x01\x00\x00\xc3\x02\x8d\x06\x00\x00\x00\x00\x0b\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x2d\x00\x00\x0b\x2d\x00\x00\x00\x00\x00\x00\x0b\x2d\x0b\x2d\x00\x00\x00\x00\x95\x06\x8e\x06\x9d\x06\x9e\x06\x9f\x06\xa2\x06\xa3\x06\xa5\x06\xa9\x06\xaa\x06\xb1\x06\xaf\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\xbe\x06\x00\x00\xb4\x06\xd9\x06\x00\x00\x00\x00\x00\x00\x68\x04\xc0\x01\xd6\x06\xbf\x06\x00\x00\x00\x00\x00\x00\x1b\x07\x00\x00\xd9\x20\xd9\x20\x4c\x01\x00\x00\x65\x02\xd9\x20\x00\x00\x00\x00\xe5\x06\x00\x00\x00\x00\x7e\x18\x44\x0e\x54\x25\xe0\x06\xe4\x17\x00\x00\xd9\x20\xe6\x1a\xe4\x17\x00\x00\xd9\x20\xe6\x1a\xe4\x17\x00\x00\xc3\x06\x00\x00\x00\x00\x00\x00\x4a\x17\xe3\x06\x00\x00\x66\x26\x00\x00\x00\x00\x00\x00\x00\x00\xde\x0e\x50\x00\xd4\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x06\xd0\x06\x00\x00\xcd\x06\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x45\x00\x00\x00\x00\xf1\x06\x00\x00\x7b\x00\xfc\x06\x99\x46\x4d\x01\x5d\x01\x00\x00\x00\x00\xae\x07\x6f\x1b\x5f\x01\x00\x00\xfe\x06\x6c\x02\xb8\x02\xf5\x06\x00\x00\x06\x07\x04\x07\xd8\x06\xf3\x06\x0a\x07\x00\x00\x10\x07\xf6\x06\xf9\x06\xbd\x44\xbd\x44\x00\x00\x12\x07\x23\x05\x6d\x03\x0b\x07\x0c\x07\x14\x07\x00\x00\xf4\x06\xeb\x08\x00\x00\x00\x00\xd9\x20\xe4\x17\x5b\x00\x9e\x36\x20\x00\x00\x00\x0f\x07\x88\x01\x27\x07\x99\x46\x00\x00\x00\x00\x53\x00\x00\x00\xd9\x20\x71\x1e\x9e\x36\x64\x07\x00\x00\x37\x07\x1c\x07\xc3\x04\x00\x00\x00\x00\x00\x00\x00\x00\x72\x07\x54\x00\xc0\x03\xf1\x03\x00\x00\x38\x07\x8c\x2d\xfb\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x3e\x79\x46\x19\x07\x8c\x2d\x00\x00\x79\x46\xc1\x45\x0b\x1f\x0b\x1f\x76\x07\x00\x00\xb9\x00\x00\x00\x11\x07\x00\x00\x13\x07\x00\x00\x00\x00\xdd\x44\xdd\x44\x00\x00\x00\x00\xdd\x44\xef\x26\x45\x07\x47\x07\x2c\x04\x4e\x07\xd9\x20\x2f\x04\x00\x00\x00\x00\x00\x00\x8a\x07\x00\x00\x82\x04\x82\x04\x00\x00\x00\x00\x00\x00\x9a\x07\x00\x00\x39\x07\x00\x00\xde\x0e\x3e\x07\x66\x01\x66\x01\x3e\x07\x2d\x07\x00\x00\x00\x00\x23\x05\x65\x07\x00\x00\x00\x00\x23\x05\x00\x00\x00\x00\x66\x07\x00\x00\x00\x00\x00\x00\x4b\x02\x00\x00\x00\x00\x5c\x01\x49\x07\xd9\x20\xe1\x45\x9b\x07\x00\x00\x52\x07\x43\x07\x00\x00\x00\x00\x44\x07\x00\x00\x80\x3e\x00\x00\x6b\x07\x6f\x07\x73\x07\x77\x07\x1d\x46\x00\x00\x00\x00\x0d\x2e\x6e\x07\x0d\x2e\x99\x46\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x04\x0d\x2e\x00\x00\x00\x00\x0d\x2e\x56\x07\x00\x00\xd4\x46\x00\x00\xb5\x04\x00\x00\x78\x07\xb1\x07\x00\x00\x00\x00\xbe\x04\x6a\x07\x9e\x36\x7a\x07\x8e\x2e\x8e\x2e\xb4\x07\xca\x07\x82\x07\x0f\x2f\x20\x00\x00\x00\x8c\x07\x00\x00\x00\x00\x86\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x2f\x00\x00\x7f\x07\x0f\x2f\x00\x00\x00\x00\x00\x00\x61\x07\x00\x00\xe0\x11\xd9\x20\x00\x00\x00\x00\x90\x2f\x1d\x46\x81\x07\x9e\x36\x90\x2f\x90\x2f\x24\x09\x00\x00\x00\x00\x84\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x2c\x02\x00\x00\x00\x00\x73\x21\x00\x00\x65\x01\x00\x00\x00\x00\x00\x00\x0d\x22\x00\x00\x50\x00\x88\x07\x00\x00\x15\x05\x00\x00\x09\x1c\x98\x07\x00\x00\x67\x07\x00\x00\x00\x00\xa3\x1c\x00\x00\x00\x00\x00\x00\x0d\x22\xa5\x1f\x0d\x22\x00\x00\x00\x00\xe4\x17\xfd\x42\x00\x00\x00\x00\x00\x00\x11\x30\x00\x00\x00\x00\xb2\x07\x00\x00\xa1\x07\x00\x00\xa2\x07\x9f\x07\x90\x07\x11\x30\x00\x00\x11\x30\x70\x07\x1e\x05\x00\x00\xab\x07\xab\x07\x02\x08\x46\x02\x03\x08\x00\x00\x2c\x00\x2c\x00\x00\x00\xb3\x07\x9d\x07\x00\x00\x94\x07\x00\x00\x00\x00\x00\x00\xbc\x07\x00\x00\x00\x00\x00\x00\x00\x00\xba\x07\x00\x00\xd1\x07\x00\x00\x00\x00\x00\x00\x16\x08\xdc\x07\x0d\x22\x3f\x20\x00\x00\x00\x00\x0d\x22\x07\x08\x77\x01\x3d\x1d\x3d\x1d\x0d\x22\xc1\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x07\xc7\x07\xed\x07\x00\x00\xf7\x07\x00\x00\x24\x08\x3f\x08\x00\x00\xc2\x07\x00\x00\x48\x08\x00\x00\x62\x02\x48\x08\x2a\x05\x92\x30\x1c\x02\x13\x31\x00\x00\x00\x00\x0d\x22\x00\x00\x78\x0f\x78\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x10\x12\x10\x00\x00\x00\x00\x00\x00\x37\x08\x2f\x47\x00\x00\x08\x08\x94\x31\x00\x00\x00\x00\x1d\x46\x00\x00\x00\x00\x69\x05\xf1\x07\x3d\x46\x00\x00\x79\x46\x58\x12\x00\x00\x00\x00\xf3\x07\x00\x00\xdd\x07\x00\x00\x13\x08\x00\x00\x14\x08\x2e\x04\x00\x00\x4a\x08\x1f\x08\x21\x08\x58\x08\x01\x08\x00\x00\x7d\x05\x00\x00\x00\x00\x7d\x05\x75\x08\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x22\x2a\x08\x00\x00\x00\x00\xe0\x11\xe0\x11\x00\x00\x00\x00\x94\x31\x00\x00\x26\x08\x00\x00\xac\x05\x00\x00\x76\x00\x00\x00\x79\x01\x00\x00\x00\x00\x6d\x08\xb9\x02\x00\x00\x2f\x47\x00\x00\x00\x00\x7a\x01\x00\x00\x62\x08\x0d\x22\x15\x32\xd9\x02\x00\x00\x00\x00\x00\x00\xbc\x03\xbc\x03\x00\x00\xf7\x02\x00\x00\x32\x00\x00\x00\x6c\x08\x00\x00\x81\x08\x00\x00\x00\x00\x96\x32\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x22\x0d\x22\x0d\x22\x00\x00\x00\x00\x00\x00\x00\x00\x09\x08\x83\x08\x00\x00\x00\x00\x00\x00\x00\x00\x81\x01\x00\x00\x01\x01\x0e\x3f\xe0\x02\xd2\x05\x22\x08\x00\x00\x6d\x40\x46\x02\x00\x00\x00\x00\x00\x00\xd2\x05\x00\x00\x00\x00\x00\x00\x00\x00\x46\x02\x27\x08\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x04\x2e\x03\xc3\x03\x3d\x06\x46\x02\x00\x00\x00\x00\x00\x00\x6b\x00\x2d\x08\x28\x08\x3b\x3f\x2e\x04\x2e\x04\x00\x00\x0d\x22\x3e\x08\x00\x00\x00\x00\x63\x08\x00\x00\x00\x00\x21\x38\xf4\x46\x3c\x08\x0b\x08\x00\x00\x1b\x35\x50\x00\x2b\x08\x00\x00\x4d\x08\x2e\x08\x3a\x08\x00\x00\xac\x10\x00\x00\x97\x04\x9e\x36\x9e\x36\xfc\x0b\x9e\x36\x00\x00\x00\x00\x00\x00\x46\x11\x9e\x36\x00\x00\x00\x00\x9e\x36\x5a\x08\x00\x00\x9c\x35\x1d\x36\x2f\x47\x00\x00\xa7\x01\x2a\x03\x96\x32\x00\x00\x61\x00\x2e\x04\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x42\x08\x00\x00\x00\x00\x00\x00\x35\x08\x46\x02\x36\x08\x00\x00\x00\x00\x2f\x47\x00\x00\xc8\x01\x00\x00\x50\x00\x38\x03\x44\x08\x9e\x36\x20\x00\x00\x00\x00\x00\x5d\x08\x17\x33\x9d\x04\x00\x00\x00\x00\x98\x33\x19\x34\x00\x00\x00\x00\x6d\x03\x9a\x34\xbc\x03\x00\x00\x41\x08\x17\x00\x45\x08\x00\x00\x00\x00\x2f\x08\x56\x08\x5e\x08\x1f\x37\x00\x00\x30\x08\x0d\x22\x43\x08\x00\x00\x64\x00\x64\x00\x00\x00\x2e\x04\x00\x00\x2e\x04\x00\x00\x00\x00\x53\x08\x54\x08\x5f\x08\x60\x08\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\x58\x41\x49\x08\x00\x00\x00\x00\x46\x02\x61\x08\x50\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x02\x00\x00\xc4\x08\x95\x02\x00\x00\x1d\x00\x68\x08\x68\x08\x88\x08\x00\x00\x00\x00\x00\x00\x21\x38\x21\x38\x00\x00\x4e\x08\x00\x00\x9e\x36\x00\x00\x00\x00\x00\x00\x76\x08\x82\x08\x01\x28\x00\x00\x00\x00\xf4\x46\x00\x00\x00\x00\xc0\x08\xda\x08\x20\x00\x00\x00\x00\x00\x9e\x36\x00\x00\x00\x00\x00\x00\x00\x00\x77\x08\x46\x02\x00\x00\x00\x00\x79\x08\x00\x00\x00\x00\xce\x08\xe4\x08\x00\x00\xe4\x08\x9c\x08\x2f\x47\x00\x00\x00\x00\xa0\x37\x64\x08\x21\x38\x00\x00\xd4\x08\xe0\x08\xa0\x3e\x2e\x04\x00\x00\x2e\x04\x2e\x04\x00\x00\x2e\x04\x58\x41\x00\x00\x00\x00\xd2\x40\x00\x00\x00\x00\x00\x00\x00\x00\x85\x08\xab\x08\x00\x00\x2e\x04\xfc\x05\xfc\x05\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x08\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x08\x2e\x04\x00\x00\x00\x00\x00\x00\x00\x00"#++happyGotoOffsets :: HappyAddr+happyGotoOffsets = HappyA# "\x05\x00\xfe\xff\xd7\x08\x05\x4f\x3f\x01\xde\x0c\xab\x50\x51\x07\x0f\x4d\x01\x00\xd0\x3a\x27\x01\x07\x00\x87\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\xcf\x04\x00\x00\x00\x00\x00\x00\xfc\x01\x00\x00\x00\x00\x00\x00\xfe\x01\x00\x00\x00\x00\x3d\x05\x4b\x05\x6a\x02\x00\x00\x7a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x6b\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\x03\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\xff\xfd\x3a\x1e\x3b\x90\x09\x26\x09\xe0\x01\xed\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\xe3\x07\xfd\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x0c\x00\x00\x00\x00\xc3\x51\x09\x52\xea\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\x4f\x52\x2c\x08\x4c\x4f\xe9\x04\x31\x08\xfa\x5c\x3d\x08\x36\x5d\x00\x00\x00\x00\x00\x00\xb7\x3f\x72\x5d\xae\x5c\x82\x5d\x02\x48\x6e\x48\xaf\x46\x91\x47\xbe\x5e\xdf\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x52\x0f\x5b\x60\x3b\x46\x08\xdb\x52\x00\x00\x21\x53\x00\x00\x67\x53\x05\x08\xd2\x08\x00\x00\x00\x00\x13\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x05\x15\x01\xe0\x04\xf5\x04\x09\x05\xc2\x03\xdf\x07\x6a\x01\x20\x47\x00\x00\x00\x00\xbe\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x07\x00\x00\x00\x00\xd9\x08\xd8\x08\x00\x00\x71\x09\xa5\x08\x8a\x00\x71\x05\x22\x01\xc5\x00\xc5\x06\x3b\x04\x00\x00\x8b\x04\xfa\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x08\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x01\x00\x00\x8a\x01\x00\x00\x96\x02\x00\x08\x06\x08\x0a\x08\xf2\x08\x00\x00\x51\x04\x00\x00\x19\x06\x00\x00\xf2\x06\x41\x07\x0a\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x5e\x29\x08\xf8\x02\x00\x00\x00\x00\xb0\x08\x00\x00\x00\x00\x00\x00\xb9\x08\x00\x00\x00\x00\x77\x05\x00\x00\xe8\xff\x00\x00\x37\x00\x52\xff\x00\x00\xb6\x08\xb7\x08\x00\x00\x00\x00\x46\x03\x87\x0d\x16\x03\x6b\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x27\x6b\x22\x9a\x08\x00\x00\x00\x00\x76\x04\x00\x00\x61\x5c\x00\x00\x00\x00\x33\x0a\xfd\x03\x25\x08\xee\x08\x00\x00\x00\x00\x00\x00\xb8\x14\x93\xff\x00\x00\x00\x00\x55\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x48\xb2\x49\x00\x00\xae\x5c\x00\x00\x00\x00\x86\x04\x00\x00\xb5\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x09\x00\x00\xae\x04\x00\x00\x00\x00\xc0\x04\x88\x0a\xe1\x04\x00\x00\x00\x00\x48\x03\xc7\x03\x74\x00\x28\x05\xc9\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\xff\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x28\x00\x00\x00\xee\x18\x00\x00\x00\x00\x00\x00\xff\x04\x7e\x08\x00\x00\x93\xff\x00\x00\x00\x00\x00\x00\xda\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x5e\x00\x00\x00\x00\xb3\x44\x6f\x08\x92\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x4d\x9b\x4d\x00\x00\x00\x00\x00\x00\x8e\x08\x88\xff\x00\x00\x00\x00\xe1\x4d\xed\x04\x00\x00\x00\x00\xce\x5e\xad\x53\xb0\x03\x00\x00\x68\x03\x00\x00\x00\x00\x23\x5c\xb6\x0b\xf3\x53\x39\x54\x7f\x54\xc5\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x37\xe9\x08\x19\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\x57\x02\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x9a\x01\x00\x00\xf6\x01\x14\x25\x00\x00\xae\x3b\xcb\x3b\x00\x00\x00\x00\x3b\x07\x00\x00\x00\x00\x16\x00\x33\x08\x00\x00\xac\x02\x00\x00\x34\x08\x40\x08\x37\x09\x00\x00\x00\x00\x3b\x09\x00\x00\x00\x00\x22\x09\x00\x00\x00\x00\x00\x00\x00\x00\x54\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x3b\x00\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x40\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x38\x00\x00\xd4\x38\x00\x00\x00\x00\x00\x00\x09\x39\x26\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x08\x8a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x55\x51\x55\x65\x08\x00\x00\x00\x00\x97\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x4e\x7e\x3c\x71\x5c\x00\x00\x1e\x4a\x00\x00\xdd\x55\x3a\x4c\x8a\x4a\x00\x00\x23\x56\x82\x4c\xf6\x4a\x00\x00\x94\xff\x00\x00\x00\x00\x00\x00\x46\x49\x00\x00\x00\x00\xb0\x06\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x01\x66\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x08\x00\x00\xa5\x01\x00\x00\x67\x08\x00\x00\x00\x00\x94\x00\x00\x00\x69\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x05\xcf\x08\x00\x00\x00\x00\x83\x07\xa1\x01\x00\x00\x00\x00\xf0\x04\x00\x00\x00\x00\xee\x18\x00\x00\x00\x00\x23\x5c\x62\x4b\x00\x00\x38\x08\xba\xff\x00\x00\x00\x00\x52\x08\x00\x00\xb8\x01\x00\x00\x00\x00\x0b\x00\x00\x00\x69\x56\x73\x4e\x3b\x26\x09\x09\x66\x05\x21\x09\x00\x00\x36\x09\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x09\xce\x05\x36\x05\x33\x09\x00\x00\x00\x00\x05\x23\xb8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\xff\xa6\x02\x70\x08\x4f\x0c\x00\x00\xed\xff\xf4\xff\xf1\x50\x37\x51\x16\x09\x00\x00\x00\x00\x00\x00\x1a\x09\x00\x00\x13\x09\x00\x00\x00\x00\x1f\x02\x93\x09\x00\x00\x00\x00\xb1\xff\x0a\x5f\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x56\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x09\x00\x00\x80\x09\x82\x09\x00\x00\x00\x00\x00\x00\xb4\x03\x00\x00\x6d\x09\x00\x00\xcb\x01\x7a\x09\x2a\x09\x2b\x09\x83\x09\x72\x09\x00\x00\x00\x00\x4f\x08\x00\x00\x00\x00\x00\x00\x7d\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x5b\x1a\x00\x46\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x02\x00\x00\x00\x00\x11\x3c\x63\x09\x68\x39\x56\x00\x00\x00\x4e\x09\x00\x00\x00\x00\x00\x00\x00\x00\x42\x09\xcc\x0a\x00\x00\x00\x00\xb6\x39\x00\x00\x00\x00\x15\x02\x00\x00\x4c\x09\x00\x00\x00\x00\x45\x09\x00\x00\x00\x00\xec\x05\x00\x00\x3a\x28\x00\x00\x17\x24\xb2\x25\x14\x09\xa5\x05\x00\x00\xd4\x39\xc3\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x0b\x00\x00\x00\x00\x60\x0b\x00\x00\x00\x00\x00\x00\x78\x05\x00\x00\x40\x07\xf5\x56\x00\x00\x00\x00\x6c\x0c\x7b\x03\x00\x00\x3b\x29\xe3\x36\xa2\x3c\x0a\x06\x00\x00\x00\x00\x88\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x57\x00\x00\x95\x08\x00\x00\x00\x00\x83\x04\x00\x00\xbf\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x4f\x00\x00\x00\x00\x00\x00\xc7\x57\x1e\x50\x0d\x58\x00\x00\x00\x00\xce\x4b\x8b\x01\x00\x00\x00\x00\x00\x00\x01\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x03\x5f\x3c\x00\x00\x22\x3a\x22\x00\xab\x09\x00\x00\x9a\x09\x9d\x09\x00\x00\x15\x00\x00\x00\x00\x00\xfb\xff\xfd\xff\x00\x00\x00\x00\x8f\x03\x00\x00\xaf\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x09\xe7\x08\x53\x58\x65\x50\x00\x00\x00\x00\x99\x58\x00\x00\x00\x00\xc9\x4c\xd8\x4f\xdf\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x09\xb1\x05\x00\x00\xc5\xff\x00\x00\x1d\x09\x00\x00\x85\x09\xca\x05\x00\x00\xf8\x3c\x00\x00\x1f\x38\x00\x00\x00\x00\x25\x59\x00\x00\x46\x04\xc5\x04\x00\x00\x30\x09\xdd\x05\x00\x00\x00\x00\x00\x00\x4a\x02\xc9\x02\x00\x00\x00\x00\x00\x00\x87\x09\xf0\xff\x00\x00\x00\x00\xa7\x0c\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\xca\x02\xee\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x09\x00\x00\x00\x00\xb9\x09\x9c\x09\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x59\x00\x00\x00\x00\x00\x00\x42\x06\xc1\x06\x00\x00\x00\x00\xfe\x0c\x00\x00\x00\x00\x00\x00\x8b\x09\x00\x00\x7f\x09\x00\x00\xb1\x08\x00\x00\x00\x00\x89\x09\x00\x00\x00\x00\x15\x02\x00\x00\x00\x00\xb4\x08\x00\x00\x8d\x09\xe1\x5b\x44\x04\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x02\xb1\x03\x00\x00\x7b\x05\x00\x00\x83\x02\x00\x00\x34\x09\x00\x00\xe3\x05\x00\x00\x00\x00\x81\x0b\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x59\xf7\x59\x3d\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x08\x00\x00\x00\x00\x26\x00\x00\x00\xbe\x09\x00\x00\x00\x00\x55\x00\xe3\xff\x00\x00\x00\x00\x00\x00\xc0\x09\x00\x00\x78\x02\x8d\x02\x00\x00\x27\x00\xba\x09\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x08\x5f\x03\x9c\x04\x4e\x05\x2b\x00\x00\x00\x00\x00\x00\x00\x03\x00\xd3\x09\x00\x00\x29\x00\xbd\x08\xbf\x08\x00\x00\x83\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x06\x24\x02\x00\x00\xbe\x08\x00\x00\x2a\x04\xc1\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x05\x00\x00\x94\x09\x42\x05\x3d\x2a\xee\x18\x3f\x2b\x00\x00\x00\x00\x00\x00\x44\x05\x40\x06\x00\x00\x00\x00\x59\x08\x9e\x09\x00\x00\x46\x01\x48\x02\x1b\x00\x00\x00\xc5\x08\x00\x00\x5b\x3d\x00\x00\x54\x06\xd0\x08\x00\x00\x16\x02\x32\x02\x00\x00\xd5\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x27\x02\x00\x00\xdc\x08\x00\x00\xe5\x08\x00\x00\x00\x00\x8d\x08\xcd\xff\x00\x00\x00\x00\xa3\x09\x39\x0d\xb5\x09\x00\x00\x00\x00\x6d\x3a\xb2\x3a\x00\x00\x00\x00\xa2\xff\x15\x0c\xad\x05\x00\x00\x00\x00\xe2\x08\x00\x00\x00\x00\x00\x00\xa5\x03\x00\x00\x00\x00\x10\x03\x00\x00\xb7\x03\xc9\x5a\x00\x00\x00\x00\xe7\x09\xf6\x09\x00\x00\xff\xff\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x03\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x09\xef\x09\x00\x00\x00\x00\x00\x00\x00\x00\x10\x04\xa2\x01\x00\x00\x9a\xff\x00\x00\xa6\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x09\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x73\x09\xf8\x05\xd2\xff\x00\x00\x00\x00\x93\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x09\x16\x06\x00\x00\x1d\x06\x00\x00\x12\x00\x00\x00\x00\x00\x10\x03\xcf\x03\x66\x04\x00\x00\x00\x00\x00\x00\x1f\x00\xec\x08\x00\x00\x02\x00\xf4\x08\x00\x00\xf5\xff\x5f\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x08\x03\x0a\x07\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x28\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x08\x00\x00\x00\x00\x00\x00\x00\x00"#++happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int#+happyAdjustOffset off = off++happyDefActions :: HappyAddr+happyDefActions = HappyA# "\xc0\xff\xc1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\xfd\x00\x00\x00\x00\xbf\xff\xc0\xff\x00\x00\xf2\xff\x17\xfd\x14\xfd\x11\xfd\x01\xfd\xff\xfc\x00\xfd\x0d\xfd\xfe\xfc\xfd\xfc\xfc\xfc\x0f\xfd\x0e\xfd\x10\xfd\x0c\xfd\x0b\xfd\xfb\xfc\xfa\xfc\xf9\xfc\xf8\xfc\xf7\xfc\xf6\xfc\xf5\xfc\xf4\xfc\xf3\xfc\xf1\xfc\xf2\xfc\x00\x00\x12\xfd\x13\xfd\x00\x00\x8b\xff\x00\x00\xb1\xff\xc2\xff\x8b\xff\xd1\xfc\x00\x00\x00\x00\x00\x00\x00\x00\xaa\xfe\xa9\xfe\x00\x00\x00\x00\xa0\xfe\x99\xfe\x93\xfe\x90\xfe\x8e\xfe\x7c\xfe\x00\x00\x89\xfe\x4d\xfd\x8d\xfe\x46\xfd\x3b\xfd\x3e\xfd\x35\xfd\x88\xfe\x8c\xfe\x21\xfd\x1d\xfd\x72\xfe\x67\xfe\x1b\xfd\x1a\xfd\x1c\xfd\x00\x00\x00\x00\x32\xfd\xa6\xfe\x31\xfd\xa7\xfe\x1f\xfd\xcd\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\xfd\x38\xfd\x33\xfd\x34\xfd\x3c\xfd\x36\xfd\x37\xfd\x74\xfd\x73\xfe\x74\xfe\x7a\xfe\x00\x00\x1d\xfe\x1c\xfe\x00\x00\xf1\xff\x63\xfd\x56\xfd\x62\xfd\xef\xff\xf0\xff\x25\xfd\x09\xfd\x0a\xfd\x05\xfd\x02\xfd\x61\xfd\xee\xfc\x52\xfd\xeb\xfc\xe8\xfc\x04\xfd\xf0\xfc\xef\xfc\x00\x00\x00\x00\x00\x00\x00\x00\xec\xfc\x03\xfd\xe9\xfc\xed\xfc\x06\xfd\xea\xfc\xdc\xfd\x81\xfd\x16\xfe\x04\xfe\x15\xfe\x00\x00\x00\x00\x05\xfe\xfa\xfd\xf7\xfd\xf5\xfd\xe6\xfd\x00\x00\x00\x00\x86\xfd\x84\xfd\xf2\xfd\xf1\xfd\xf3\xfd\xf4\xfd\xf0\xfd\xe7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x73\xfd\xe7\xfc\xe6\xfc\xef\xfd\xee\xfd\xe3\xfc\xe2\xfc\xe5\xfc\xe4\xfc\xe1\xfc\xe0\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xfd\x00\x00\xd8\xfd\x00\x00\x00\x00\x78\xff\x2a\xfe\x00\x00\x00\x00\x13\xfe\x00\x00\x14\xfd\x76\xff\x75\xff\x74\xff\x00\x00\x00\x00\x21\xfe\x21\xfe\x21\xfe\x00\x00\x71\xfd\x00\x00\x00\x00\x94\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x6e\xff\x6d\xff\x6c\xff\x19\xff\x6b\xff\x6a\xff\x36\xfe\x5d\xff\x35\xfe\x3e\xfe\x5c\xff\x39\xfe\x5b\xff\x3d\xfe\x3c\xfe\x3b\xfe\x3a\xfe\x00\x00\x29\xff\x00\x00\x48\xff\x4c\xff\x28\xff\x00\x00\x00\x00\x00\x00\xe0\xfe\xcb\xfe\xd0\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfc\xd4\xfc\xd3\xfc\xd2\xfc\x00\x00\x00\x00\x85\xff\x00\x00\x00\x00\x00\x00\x00\x00\x8b\xff\xc3\xff\x8b\xff\x00\x00\x88\xff\x00\x00\x00\x00\x00\x00\x83\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\xfd\x5d\xfd\x67\xfd\x19\xfd\x5f\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd1\xfe\x00\x00\x69\xfd\x00\x00\xcc\xfe\x00\x00\x00\x00\xe1\xfe\xde\xfe\x00\x00\x5c\xfd\x00\x00\x00\x00\x00\x00\x68\xff\x00\x00\x00\x00\x00\x00\x99\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\xff\x4b\xff\x4a\xff\x6d\xfe\x00\x00\x64\xfe\x00\x00\x1c\xff\x00\x00\x2b\xfd\x00\x00\x2a\xfd\x2c\xfd\x00\x00\x00\x00\x00\x00\x19\xff\x00\x00\x93\xfd\xcf\xfd\x16\xfe\x00\x00\x00\x00\x28\xfd\x00\x00\x27\xfd\x29\xfd\x23\xfd\x07\xfd\x00\x00\x08\xfd\x52\xfd\x00\x00\x00\x00\xd6\xfc\x04\xfd\x5a\xfd\xda\xfc\x00\x00\x5c\xfd\xb2\xfe\x00\x00\x72\xfd\x70\xfd\x6e\xfd\x6d\xfd\x6a\xfd\x00\x00\x00\x00\x00\x00\x20\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xfe\x00\x00\xeb\xfe\xeb\xfe\x00\x00\x00\x00\x00\x00\x77\xff\xe2\xfd\x50\xfd\xe3\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xff\x6f\xff\x00\x00\x00\x00\x00\x00\xe4\xfd\xe5\xfd\x00\x00\xd5\xfd\xf4\xfd\x00\x00\x00\x00\x07\xfd\x08\xfd\x00\x00\x58\xfd\x00\x00\xae\xfd\xad\xfd\x00\x00\xc3\xfd\x00\x00\xc2\xfd\x55\xfd\x91\xfd\x0b\xfe\xf8\xfd\x90\xfd\x8d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\xfd\x83\xfd\x87\xfd\x87\xfd\x00\x00\x09\xfe\x80\xfd\x01\xfe\x00\x00\x0d\xfe\x98\xfd\x00\x00\x00\x00\x0a\xfe\x00\x00\x00\x00\x00\x00\x7e\xfd\xfd\xfd\x00\x00\x08\xfe\x03\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\xfe\x65\xfd\x64\xfd\x8b\xfe\x8a\xfe\x76\xfe\x2e\xfd\x6d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x6c\xfe\x00\x00\x00\x00\x00\x00\x83\xfe\x00\x00\x3e\xfd\x00\x00\x00\x00\xa6\xfe\x00\x00\x85\xfe\x00\x00\x48\xfd\x00\x00\x49\xfd\x00\x00\x49\xfe\x47\xfe\xce\xfc\x00\x00\xa4\xfe\xa5\xfe\x00\x00\x67\xfe\x66\xfe\x00\x00\x00\x00\x8f\xfe\x00\x00\x00\x00\xa8\xfe\x87\xfe\x00\x00\x00\x00\xe9\xff\x00\x00\x00\x00\xae\xff\x88\xff\xad\xff\x00\x00\x00\x00\xbc\xff\xdd\xfc\xdc\xfc\xbc\xff\xac\xff\xaa\xff\xab\xff\x8c\xff\xed\xff\xde\xfc\xdf\xfc\xea\xff\x00\x00\xd9\xff\xdd\xff\xda\xff\xdc\xff\xdb\xff\xde\xff\xec\xff\xa2\xfe\x98\xfe\xa1\xfe\x00\x00\x68\xfe\x00\x00\x00\x00\xad\xfe\x00\x00\x00\x00\x86\xfe\x80\xfe\x00\x00\x7f\xfe\x47\xfd\x44\xfd\x4a\xfd\x4c\xfd\xdb\xfc\x45\xfd\x00\x00\x7e\xfe\x00\x00\x4b\xfd\x81\xfe\x82\xfe\x00\x00\x00\x00\x20\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x32\xfd\x31\xfd\xa7\xfe\x1f\xfd\x33\xfd\x34\xfd\x37\xfd\x6c\xfe\x00\x00\x6e\xfe\x7b\xfe\xee\xff\x59\xfd\x60\xfd\x15\xfd\x57\xfd\x51\xfd\x24\xfd\x17\xfe\x18\xfe\x19\xfe\x1a\xfe\x1b\xfe\xb0\xfe\x14\xfe\xfc\xfd\x00\x00\x7f\xfd\x7c\xfd\x79\xfd\x7b\xfd\x82\xfd\xf9\xfd\x00\x00\x00\x00\x00\x00\xa9\xfd\xa7\xfd\x99\xfd\x96\xfd\x00\x00\x02\xfe\x00\x00\x00\x00\x00\x00\x88\xfd\x00\x00\x00\x00\x00\xfe\xff\xfd\x00\x00\x8f\xfd\x0f\xfe\x00\x00\x00\x00\x8d\xfd\x00\x00\x00\x00\xe9\xfd\xc1\xfd\x00\x00\x00\x00\xe8\xfd\x00\x00\x00\x00\x00\x00\x16\xfd\xc5\xfd\xc9\xfd\xea\xfd\xcb\xfd\xc4\xfd\xca\xfd\xeb\xfd\x00\x00\xe1\xfd\xde\xfd\xdf\xfd\xd0\xfd\xd1\xfd\x00\x00\x00\x00\xdd\xfd\xe0\xfd\xd9\xfd\xd7\xfd\x4e\xfd\x00\x00\x00\x00\x4f\xfd\x2b\xfe\x2f\xfd\x72\xff\x30\xfd\x54\xfd\x00\x00\x2d\xfe\xaf\xfe\x00\x00\x9c\xfe\x97\xfe\x00\x00\x67\xfe\x00\x00\x00\x00\x34\xfe\xec\xfe\xb4\xfe\x33\xfe\x00\x00\x76\xfd\xf2\xfd\x00\x00\x00\x00\x00\x00\x71\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfc\xd7\xfc\x16\xfd\xcd\xfd\xec\xfd\xed\xfd\xce\xfd\x00\x00\x00\x00\x00\x00\x27\xff\xb3\xfe\x00\x00\x97\xfe\x00\x00\x67\xfe\x12\xfe\x37\xfe\xe4\xfe\x2f\xfe\x00\x00\x00\x00\x00\x00\xf9\xfe\x5f\xfe\x25\xff\x00\x00\x4c\xff\x4d\xff\x4e\xff\x50\xff\x4f\xff\xef\xfe\x16\xff\x00\x00\x23\xff\x53\xff\x00\x00\x00\x00\x00\x00\xbe\xfe\xbd\xfe\xbc\xfe\xbb\xfe\xba\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x0d\xff\x0a\xff\x00\x00\x00\x00\x00\x00\xd8\xfe\xdd\xfe\x00\x00\x65\xff\xe2\xfe\xca\xfe\xc5\xfe\xc9\xfe\x67\xff\xcd\xfe\x00\x00\xcf\xfe\x66\xff\xd2\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\xff\x38\xfe\x86\xff\x7f\xff\x84\xff\xbc\xff\xbc\xff\xb8\xff\xb7\xff\xb4\xff\x6f\xff\xb9\xff\x8a\xff\xb5\xff\xb6\xff\xa8\xff\x00\x00\x00\x00\xa8\xff\x81\xff\x80\xff\x61\xff\x00\x00\x00\x00\x5e\xff\x62\xff\x00\x00\xc4\xfe\xc2\xfe\x00\x00\xd3\xfe\x68\xfd\xce\xfe\x00\x00\xc6\xfe\xe3\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x0f\xff\x10\xff\x00\x00\x08\xff\x09\xff\x04\xff\x00\x00\x0c\xff\x00\x00\xc0\xfe\x00\x00\xb8\xfe\xb7\xfe\xb9\xfe\x00\x00\xbf\xfe\x59\xff\x00\x00\x47\xff\x00\x00\x00\x00\x17\xff\x15\xff\x14\xff\x11\xff\x12\xff\x54\xff\x00\x00\x00\x00\x69\xff\x55\xff\x00\x00\x63\xfe\x61\xfe\x00\x00\x5a\xff\x00\x00\x1d\xff\x00\x00\xe4\xfe\x31\xfe\x30\xfe\x00\x00\x00\x00\x00\x00\x96\xfe\x00\x00\x00\x00\x5a\xfe\x45\xfe\x00\x00\x00\x00\x27\xff\x1a\xff\x00\x00\xcc\xfd\xc8\xfd\xd9\xfc\x26\xfd\x22\xfd\x5b\xfd\xb1\xfe\x29\xfe\x6f\xfd\x6c\xfd\x5e\xfd\x6b\xfd\x26\xfe\x00\x00\x1f\xfe\x00\x00\x00\x00\x23\xfe\x28\xfe\xe7\xfe\x77\xfd\xea\xfe\xed\xfe\x00\x00\xe6\xfe\xe9\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xfd\xd2\xfd\x71\xff\xd4\xfd\xd6\xfd\xdb\xfd\xc7\xfd\xc6\xfd\xcf\xfd\xbb\xfd\xaa\xfd\xba\xfd\xb8\xfd\xb5\xfd\xb4\xfd\x00\x00\xac\xfd\xcf\xfd\xbd\xfd\xbf\xfd\xbc\xfd\x00\x00\x8e\xfd\x00\x00\xa2\xfd\x9e\xfd\x00\x00\xa3\xfd\x00\x00\x00\x00\xa4\xfd\x00\x00\x06\xfe\x8c\xfd\x89\xfd\x8b\xfd\x07\xfe\x10\xfe\x00\x00\x00\x00\x00\x00\x97\xfd\x0c\xfe\x00\x00\x00\x00\xf6\xfd\x77\xfe\x18\xfd\x00\x00\x2d\xfd\x6b\xfe\x6a\xfe\x69\xfe\x00\x00\x5d\xfe\x00\x00\x00\x00\xcf\xfc\x00\x00\xa3\xfe\x00\x00\x00\x00\x00\x00\xeb\xff\xa8\xff\xa8\xff\x00\x00\xa1\xff\x00\x00\xe8\xff\xc1\xff\xc1\xff\xd8\xff\x00\x00\xcf\xfc\xd0\xfc\xcd\xfc\x75\xfe\x7d\xfe\x84\xfe\x00\x00\x7d\xfd\x7a\xfd\x95\xfd\xa8\xfd\x01\xfe\x8a\xfd\x00\x00\xa6\xfd\xa1\xfd\x9d\xfd\xe4\xfe\x9a\xfd\x00\x00\x9f\xfd\xa5\xfd\x11\xfe\xc0\xfd\xb3\xfd\xf6\xfc\x00\x00\x00\x00\x00\x00\x70\xff\x8d\xff\x73\xff\x9e\xfe\x95\xfe\x9d\xfe\x00\x00\xae\xfe\x2c\xfe\x75\xfd\xee\xfe\x78\xfd\x00\x00\xac\xfe\x00\x00\x1e\xfe\x00\x00\x1b\xff\x5a\xfe\x45\xfe\x26\xff\xcd\xfc\x57\xff\x44\xfe\x42\xfe\x48\xff\x45\xfe\x00\x00\x00\x00\x9d\xfe\x00\x00\xe5\xfe\x32\xfe\x00\x00\xfa\xfe\xfd\xfe\xfd\xfe\x5e\xfe\x5f\xfe\x5f\xfe\x24\xff\x18\xff\xf0\xfe\xf3\xfe\xf3\xfe\x13\xff\x21\xff\x22\xff\x42\xff\x00\x00\x38\xff\x00\x00\x00\x00\xc1\xfe\x53\xfd\x00\x00\x0b\xff\x0e\xff\x00\x00\x00\x00\xd7\xfe\xd5\xfe\x00\x00\x00\x00\xdc\xfe\xda\xfe\x00\x00\xc8\xfe\x00\x00\xc3\xfe\x00\x00\x64\xff\x00\x00\x00\x00\x82\xff\x00\x00\x00\x00\x00\x00\x00\x00\x89\xff\x8e\xff\x00\x00\xbe\xff\xbd\xff\x00\x00\x7d\xff\x5f\xff\x60\xff\xc7\xfe\xdb\xfe\x00\x00\x00\x00\xd6\xfe\xd9\xfe\xeb\xfe\xeb\xfe\x07\xff\xb5\xfe\x00\x00\x46\xff\x00\x00\x58\xff\x00\x00\xf8\xfe\x19\xff\xf4\xfe\x00\x00\xf7\xfe\x29\xff\x30\xff\x00\x00\x62\xfe\x60\xfe\x03\xff\xfe\xfe\x00\x00\x02\xff\x32\xff\x00\x00\x00\x00\x00\x00\x2e\xfe\x9f\xfe\x94\xfe\x57\xfe\x57\xfe\x56\xff\x00\x00\x43\xfe\x53\xfe\x51\xfe\x4d\xfe\x52\xff\x45\xfe\x24\xfe\x25\xfe\x00\x00\xab\xfd\xb7\xfd\xb6\xfd\xb9\xfd\x00\x00\x00\x00\x00\x00\xbe\xfd\xa0\xfd\x9b\xfd\x9c\xfd\x00\x00\x00\x00\x78\xfe\x48\xfe\x46\xfe\x65\xfe\x00\x00\xcc\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\xff\xa3\xff\xa1\xff\x9e\xff\x9f\xff\xa0\xff\x00\x00\xb2\xff\x8b\xff\x8b\xff\xa2\xff\xa1\xff\x9a\xff\x92\xff\x8f\xff\x43\xfd\x90\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa1\xff\xa9\xff\xb3\xff\xd0\xff\xcd\xff\xd7\xff\xe7\xff\xf1\xfc\x00\x00\x00\x00\xcf\xff\x00\x00\x00\x00\xb2\xfd\xb1\xfd\x00\x00\xab\xfe\x51\xff\x00\x00\x67\xfe\x00\x00\x3a\xfd\x41\xfe\x00\x00\x00\x00\x58\xfe\x55\xfe\x00\x00\x00\x00\x00\x00\xfc\xfe\xff\xfe\x34\xff\x20\xff\x00\x00\x00\x00\x00\x00\x00\x00\x31\xff\xfb\xfe\xf2\xfe\xf5\xfe\x00\x00\x2f\xff\xf1\xfe\x00\x00\x19\xff\x41\xff\x39\xff\x39\xff\x00\x00\xb6\xfe\x00\x00\x00\x00\x00\x00\xdf\xfe\x7b\xff\x00\x00\xc5\xff\x8b\xff\x8b\xff\xc4\xff\x00\x00\x00\x00\x7e\xff\x87\xff\x7c\xff\x00\x00\xa1\xff\x00\x00\x06\xff\x05\xff\x45\xff\x43\xff\x00\x00\x3a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x27\xff\x2e\xff\xf6\xfe\x25\xff\x00\x00\x20\xff\x33\xff\x36\xff\x00\x00\x00\x00\x00\xff\x5c\xfe\x00\x00\x00\x00\x57\xfe\x5b\xfe\x70\xfe\x97\xfe\x00\x00\x40\xfe\x39\xfd\xcf\xfc\x00\x00\x00\x00\x4c\xfe\x91\xfe\xcf\xfc\x00\x00\x00\x00\x0e\xfe\xc8\xff\xc9\xff\xc6\xff\x00\x00\xc7\xff\x00\x00\xce\xff\xa7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xff\x00\x00\x91\xff\x9c\xff\x9d\xff\x98\xff\xa4\xff\xaf\xff\xb0\xff\xa1\xff\x00\x00\x97\xff\x95\xff\x94\xff\x93\xff\x42\xfd\x41\xfd\x3f\xfd\x40\xfd\x00\x00\xd3\xff\xd1\xff\x00\x00\xe3\xff\x00\x00\xa8\xff\xa8\xff\x00\x00\xb0\xfd\x4f\xfe\x92\xfe\x00\x00\x00\x00\x4e\xfe\xcd\xfc\x3f\xfe\x00\x00\x59\xfe\x54\xfe\x56\xfe\x00\x00\x88\xfe\x00\x00\x1f\xff\x35\xff\x00\x00\x01\xff\x37\xff\x5a\xfe\x45\xfe\x27\xff\x3e\xff\x40\xff\x3b\xff\x3d\xff\x3f\xff\x44\xff\xd4\xfe\x00\x00\xa1\xff\xbb\xff\xba\xff\x00\x00\x7a\xff\x3c\xff\x5a\xfe\x45\xfe\x2d\xff\x45\xfe\x88\xfe\x00\x00\x6f\xfe\x52\xfe\x4c\xfe\xcf\xfc\x4b\xfe\xfe\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xff\xe4\xff\x00\x00\xd6\xff\xd4\xff\x00\x00\x99\xff\xa5\xff\xa3\xff\x96\xff\xd5\xff\xd2\xff\xe5\xff\x00\x00\x00\x00\xe2\xff\x00\x00\x00\x00\x00\x00\x50\xfe\x1e\xff\x2b\xff\x2c\xff\x45\xfe\x79\xff\x2a\xff\xca\xff\xcb\xff\x00\x00\x00\x00\xe1\xff\xdf\xff\xe0\xff"#++happyCheck :: HappyAddr+happyCheck = HappyA# "\xff\xff\x00\x00\x0d\x00\x3a\x00\x05\x00\x06\x00\x23\x00\x24\x00\x06\x00\x4f\x00\x0f\x00\x10\x00\x0f\x00\x10\x00\x13\x00\x11\x00\x13\x00\x13\x00\x4f\x00\x10\x00\x0c\x00\x0d\x00\x13\x00\x12\x00\x13\x00\x14\x00\x13\x00\x14\x00\x4f\x00\x18\x00\x08\x00\x09\x00\x0a\x00\x4f\x00\x1b\x00\x04\x00\x1d\x00\x74\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x04\x00\x09\x00\x0a\x00\x04\x00\x08\x00\x09\x00\x0a\x00\x08\x00\x09\x00\x0a\x00\x44\x00\x7d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x21\x00\x22\x00\x23\x00\x24\x00\xa4\x00\x21\x00\x22\x00\x23\x00\x24\x00\xa1\x00\x5c\x00\x22\x00\x23\x00\x24\x00\x7d\x00\x5c\x00\x23\x00\x24\x00\x3b\x00\x3c\x00\x23\x00\x24\x00\x00\x00\x5d\x00\x7c\x00\x7d\x00\x13\x00\x01\x00\x44\x00\xa8\x00\xa9\x00\xa7\x00\xa8\x00\xa9\x00\xa2\x00\x00\x00\xcb\x00\xcb\x00\x45\x00\x35\x00\x13\x00\x3b\x00\x3c\x00\xa2\x00\xde\x00\x58\x00\xa3\x00\xa4\x00\x11\x00\x0a\x00\x19\x00\x56\x00\x51\x00\xa2\x00\x50\x00\x51\x00\x64\x00\x21\x01\xa2\x00\x34\x00\x6b\x00\x25\x01\x11\x00\x13\x00\x25\x00\x07\x01\x08\x01\x19\x00\x13\x00\x2a\x00\x2b\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x54\x00\x11\x00\x29\x00\x2a\x00\x2b\x00\x71\x00\x72\x00\x75\x00\x4e\x00\x4d\x00\x81\x00\x5d\x00\x4d\x00\x4f\x00\x77\x00\x89\x00\x56\x00\x89\x00\x80\x00\x25\x01\x34\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x34\x00\x35\x00\x8a\x00\x3e\x00\x3f\x00\x63\x00\xf4\x00\xf5\x00\x54\x00\x4d\x00\x89\x00\xf9\x00\x23\x01\xfb\x00\xfc\x00\x47\x00\x71\x00\x72\x00\x54\x00\x63\x00\x71\x00\x0c\x00\x89\x00\x66\x00\x73\x00\x25\x01\x25\x01\x27\x01\x89\x00\x78\x00\x47\x00\xb3\x00\x72\x00\x67\x00\x1f\x01\x28\x01\x66\x00\x13\x01\x80\x00\xfd\x00\x16\x01\x2e\x01\x75\x00\x89\x00\x13\x01\x6b\x00\x1c\x01\x16\x01\x6b\x00\x1f\x01\x56\x00\x09\x01\x0a\x01\x1c\x01\x5a\x00\x89\x00\x28\x01\x89\x00\xc8\x00\x28\x01\x80\x00\x51\x00\x2e\x01\x13\x01\x54\x00\x2e\x01\x16\x01\x28\x01\x1a\x01\x1b\x01\x5b\x00\x1d\x01\x1c\x01\x2e\x01\x13\x01\x21\x01\x28\x01\x16\x01\x28\x01\x98\x00\x4d\x00\xc8\x00\x2e\x01\x1c\x01\x2e\x01\x89\x00\x28\x01\x82\x00\x82\x00\xf7\x00\xf8\x00\x28\x01\x2e\x01\xfb\x00\xfc\x00\x16\x01\xfe\x00\x2e\x01\x4d\x00\x12\x01\x16\x01\x1c\x01\x8a\x00\x00\x00\x13\x01\x98\x00\x1c\x01\x16\x01\x28\x01\x1c\x01\x2a\x01\x2b\x01\x0e\x01\x1c\x01\x58\x00\x7e\x00\x71\x00\x13\x00\x14\x01\x15\x01\x16\x01\x17\x01\x24\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x24\x01\x12\x01\x71\x00\x24\x01\x2c\x01\x01\x00\x2c\x01\x2c\x01\x63\x00\x24\x01\x12\x01\x1c\x01\x2c\x01\x16\x01\x2c\x01\x1c\x01\x2c\x01\xfd\x00\x34\x00\x1c\x01\x1c\x01\x73\x00\x74\x00\x81\x00\x1c\x01\x15\x00\x28\x01\x1c\x01\x2a\x01\x2b\x01\x28\x01\x1c\x01\x2a\x01\x2b\x01\x1c\x01\x28\x01\x13\x01\x2a\x01\x2b\x01\x16\x01\x28\x01\x00\x00\x2a\x01\x2b\x01\x28\x01\x1c\x01\x2a\x01\x2b\x01\x28\x01\x16\x01\x2a\x01\x2b\x01\x02\x01\x21\x01\x04\x01\x1c\x01\x06\x01\x02\x01\x00\x00\x04\x01\x00\x00\x06\x01\x02\x01\x63\x00\x04\x01\x65\x00\x06\x01\x10\x01\x50\x00\x12\x01\x14\x01\x15\x01\x16\x01\x66\x00\x00\x00\x14\x01\x15\x01\x16\x01\x1c\x01\x1c\x01\x14\x01\x15\x01\x16\x01\x1c\x01\x71\x00\x39\x00\x00\x00\x00\x00\x1c\x01\x3d\x00\x3e\x00\x3f\x00\x40\x00\x10\x01\x00\x00\x12\x01\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x13\x01\x13\x01\x72\x00\x16\x01\x16\x01\x1c\x01\x4e\x00\x48\x00\x49\x00\x1c\x01\x1c\x01\xfe\x00\x4f\x00\x55\x00\x56\x00\x19\x00\x75\x00\x76\x00\x5a\x00\x97\x00\x98\x00\x0c\x00\x50\x00\x5f\x00\x0b\x01\x16\x01\x0d\x01\x0e\x01\x19\x00\x2d\x00\x2e\x00\x1c\x01\x00\x00\x54\x00\x1f\x01\x2d\x00\x17\x01\x1c\x00\x19\x01\x1a\x01\x1b\x01\x6c\x00\x1d\x01\x66\x00\x4e\x00\x20\x01\x21\x01\x72\x00\x2d\x00\x79\x00\xf4\x00\xf5\x00\x56\x00\x78\x00\x71\x00\xf9\x00\x72\x00\xfb\x00\xfc\x00\x6e\x00\x66\x00\x68\x00\x66\x00\x72\x00\x54\x00\x00\x00\x16\x01\x84\x00\x85\x00\x86\x00\x67\x00\x71\x00\x1c\x01\x71\x00\x8b\x00\x1f\x01\x8d\x00\x4e\x00\x8f\x00\x90\x00\x91\x00\x13\x01\x51\x00\x54\x00\x16\x01\x54\x00\x81\x00\x56\x00\x66\x00\x66\x00\x1c\x01\x5a\x00\x4e\x00\x1f\x01\x72\x00\x80\x00\x66\x00\x14\x00\x54\x00\x71\x00\x71\x00\xad\x00\xae\x00\xaf\x00\x84\x00\x85\x00\x86\x00\x71\x00\xb4\x00\x1a\x01\x1b\x01\xb7\x00\x1d\x01\x72\x00\xba\x00\xbb\x00\x90\x00\x91\x00\xb7\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x39\x00\x31\x00\x32\x00\x72\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x9b\x00\x66\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x8a\x00\x10\x01\x54\x00\x12\x01\xf4\x00\xf5\x00\x71\x00\x4e\x00\x1e\x00\xf9\x00\x1e\x00\xfb\x00\xfc\x00\x1c\x01\x55\x00\x56\x00\xb7\x00\x50\x00\x64\x00\x5a\x00\x84\x00\x85\x00\x86\x00\x2d\x00\x5f\x00\x2d\x00\xed\x00\xee\x00\x66\x00\x19\x00\x8e\x00\x97\x00\x98\x00\x91\x00\x1f\x01\x13\x01\xf7\x00\xf8\x00\x16\x01\x71\x00\xfb\x00\xfc\x00\x97\x00\x98\x00\x1c\x01\x6c\x00\x33\x00\x1f\x01\x54\x00\x2d\x00\x79\x00\x72\x00\x00\x01\x01\x01\xa6\x00\x03\x01\x04\x01\x19\x00\x06\x01\x07\x01\x08\x01\x97\x00\x98\x00\x9b\x00\x13\x01\x14\x01\x15\x01\x16\x01\x10\x01\x11\x01\x12\x01\xb7\x00\x6c\x00\x1c\x01\x5a\x00\x1e\x01\x1f\x01\x2d\x00\x72\x00\x22\x01\x1c\x01\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\x00\x01\x01\x01\x51\x00\x03\x01\x04\x01\x54\x00\x06\x01\x07\x01\x08\x01\xe9\x00\xea\x00\x14\x00\x64\x00\xad\x00\xae\x00\xaf\x00\x10\x01\x11\x01\x12\x01\x50\x00\xb4\x00\x54\x00\x4d\x00\xb7\x00\x39\x00\x71\x00\xba\x00\xbb\x00\x1c\x01\x68\x00\x1f\x01\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x48\x00\x49\x00\x72\x00\x31\x00\x32\x00\x76\x00\x1e\x00\x4d\x00\x4e\x00\x4d\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x72\x00\x14\x01\x15\x01\x16\x01\x00\x01\x01\x01\x5a\x00\x2d\x00\x04\x01\x1c\x01\x06\x01\x5f\x00\x10\x01\x1e\x00\x12\x01\x58\x00\x64\x00\x65\x00\x1a\x00\x5c\x00\x10\x01\x68\x00\x12\x01\x10\x01\x1c\x01\x12\x01\xed\x00\xee\x00\x2d\x00\x97\x00\x98\x00\x72\x00\x1c\x01\x4f\x00\x1f\x01\x1c\x01\xf7\x00\xf8\x00\x2e\x00\x2f\x00\xfb\x00\xfc\x00\x10\x01\x64\x00\x12\x01\x1f\x00\x84\x00\x85\x00\x86\x00\x89\x00\x64\x00\x8b\x00\x8c\x00\x8b\x00\x1c\x01\x8d\x00\x71\x00\x8f\x00\x90\x00\x91\x00\x2e\x00\x2f\x00\x6c\x00\x71\x00\x13\x01\x14\x01\x15\x01\x16\x01\x72\x00\x68\x00\x04\x01\x6c\x00\x06\x01\x1c\x01\x78\x00\x1e\x01\x1f\x01\x72\x00\x7c\x00\x22\x01\x84\x00\x85\x00\x86\x00\x9b\x00\x12\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x91\x00\x1c\x01\x68\x00\xb4\x00\xb7\x00\x55\x00\xb7\x00\x39\x00\x4f\x00\xba\x00\xbb\x00\x10\x01\x72\x00\x12\x01\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x5b\x00\x5c\x00\x63\x00\x1c\x01\xf4\x00\xf5\x00\x61\x00\x4d\x00\x4e\x00\xf9\x00\x55\x00\xfb\x00\xfc\x00\x64\x00\x64\x00\x5b\x00\x5c\x00\x6c\x00\xb7\x00\x9b\x00\x5a\x00\x61\x00\x10\x01\x72\x00\x12\x01\x5f\x00\x71\x00\x71\x00\x77\x00\x78\x00\x64\x00\x65\x00\x7b\x00\x7c\x00\x1c\x01\x13\x01\x57\x00\x10\x01\x16\x01\x12\x01\xed\x00\xee\x00\x12\x01\x77\x00\x1c\x01\x80\x00\x64\x00\x1f\x01\x80\x00\x1c\x01\xf7\x00\xf8\x00\x1c\x01\x64\x00\xfb\x00\xfc\x00\x6c\x00\x00\x01\x01\x01\x71\x00\x03\x01\x04\x01\x72\x00\x06\x01\x07\x01\x08\x01\x71\x00\x9f\x00\xa0\x00\xa1\x00\x6c\x00\x6b\x00\x81\x00\x10\x01\x11\x01\x12\x01\x72\x00\x9b\x00\x13\x01\x14\x01\x15\x01\x16\x01\x76\x00\x6b\x00\x56\x00\x1c\x01\x7a\x00\x1c\x01\x5a\x00\x1e\x01\x1f\x01\x00\x01\x01\x01\x22\x01\x76\x00\x04\x01\x72\x00\x06\x01\x7a\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x10\x01\x72\x00\x12\x01\xb4\x00\x76\x00\x28\x01\xb7\x00\x39\x00\x7a\x00\xba\x00\xbb\x00\x2e\x01\x1c\x01\x67\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x64\x00\x49\x00\x9b\x00\x4f\x00\x50\x00\x6e\x00\x84\x00\x85\x00\x86\x00\x72\x00\x63\x00\x6b\x00\x65\x00\x71\x00\x64\x00\x5b\x00\x5c\x00\x5b\x00\x5c\x00\x91\x00\x5a\x00\x61\x00\x76\x00\x61\x00\x4f\x00\x5f\x00\x7a\x00\x71\x00\x6b\x00\x28\x01\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x68\x00\x2e\x01\x5b\x00\x5c\x00\x23\x00\x73\x00\xed\x00\xee\x00\x61\x00\x77\x00\x78\x00\x77\x00\x16\x01\x7b\x00\x7c\x00\x7b\x00\xf7\x00\xf8\x00\x1c\x01\x6c\x00\xfb\x00\xfc\x00\x63\x00\xb7\x00\x65\x00\x72\x00\x84\x00\x85\x00\x86\x00\x80\x00\x77\x00\x78\x00\x18\x00\x8b\x00\x1f\x01\x8d\x00\x67\x00\x8f\x00\x90\x00\x91\x00\x6b\x00\x9b\x00\x6d\x00\x28\x01\x13\x01\x14\x01\x15\x01\x16\x01\x16\x01\x2e\x01\x39\x00\x76\x00\x30\x00\x1c\x01\x1c\x01\x1e\x01\x1f\x01\x3e\x00\x3f\x00\x22\x01\x84\x00\x85\x00\x86\x00\x3b\x00\x3c\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x91\x00\x34\x00\x13\x01\xb4\x00\xb7\x00\x16\x01\xb7\x00\x39\x00\x6e\x00\xba\x00\xbb\x00\x1c\x01\x72\x00\x9b\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xfd\x00\x9b\x00\x4f\x00\x00\x01\x01\x01\x1a\x01\x1b\x01\x04\x01\x1d\x01\x06\x01\x01\x01\x58\x00\x21\x01\x04\x01\x5b\x00\x06\x01\x25\x01\x13\x00\xb7\x00\x10\x01\x5a\x00\x12\x01\x67\x00\x51\x00\x64\x00\x5f\x00\x6b\x00\x55\x00\x6d\x00\x67\x00\x71\x00\x1c\x01\x71\x00\x6b\x00\x68\x00\x6d\x00\x21\x01\x76\x00\xeb\x00\xec\x00\xed\x00\xee\x00\x77\x00\x78\x00\x76\x00\x6e\x00\x7b\x00\x7c\x00\x7a\x00\x72\x00\xf7\x00\xf8\x00\x50\x00\x51\x00\xfb\x00\xfc\x00\x89\x00\x00\x01\x01\x01\x1f\x00\x03\x01\x04\x01\x6e\x00\x06\x01\x07\x01\x08\x01\x72\x00\x9f\x00\xa0\x00\xa1\x00\x4d\x00\x20\x01\x21\x01\x10\x01\x11\x01\x12\x01\x25\x01\x4d\x00\x13\x01\x14\x01\x15\x01\x16\x01\x63\x00\x01\x01\x65\x00\x1c\x01\x04\x01\x1c\x01\x06\x01\x1e\x01\x1f\x01\x00\x01\x01\x01\x22\x01\x76\x00\x04\x01\x51\x00\x06\x01\x7a\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x10\x01\x4d\x00\x12\x01\xb4\x00\x4d\x00\x51\x00\xb7\x00\x39\x00\x51\x00\xba\x00\xbb\x00\x63\x00\x1c\x01\x65\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x76\x00\x49\x00\x13\x01\x29\x01\x4a\x00\x16\x01\x67\x00\x2d\x01\x84\x00\x85\x00\x86\x00\x1c\x01\xe8\x00\xe9\x00\xea\x00\x14\x01\x15\x01\x16\x01\x8e\x00\x72\x00\x5a\x00\x91\x00\x50\x00\x1c\x01\x76\x00\x5f\x00\x60\x00\x61\x00\x7a\x00\x51\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x84\x00\x85\x00\x86\x00\x56\x00\xeb\x00\xec\x00\xed\x00\xee\x00\x8c\x00\x8d\x00\x29\x01\x8f\x00\x90\x00\x91\x00\x2d\x01\x93\x00\xf7\x00\xf8\x00\x3e\x00\x3f\x00\xfb\x00\xfc\x00\x14\x01\x15\x01\x16\x01\xb7\x00\x84\x00\x85\x00\x86\x00\x63\x00\x1c\x01\x65\x00\x29\x01\x8b\x00\x1f\x01\x8d\x00\x2d\x01\x8f\x00\x90\x00\x91\x00\x14\x01\x15\x01\x16\x01\x28\x01\x13\x01\x14\x01\x15\x01\x16\x01\x1c\x01\x2e\x01\x29\x01\xb7\x00\x4d\x00\x1c\x01\x2d\x01\x1e\x01\x1f\x01\x50\x00\x51\x00\x22\x01\x84\x00\x85\x00\x86\x00\x50\x00\x51\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x91\x00\x29\x01\x4d\x00\xb4\x00\xb7\x00\x2d\x01\xb7\x00\x39\x00\x11\x00\xba\x00\xbb\x00\xb1\x00\xb2\x00\xb3\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4a\x00\x00\x01\x01\x01\x15\x01\x16\x01\x04\x01\x63\x00\x06\x01\x65\x00\x63\x00\x1c\x01\x65\x00\x1e\x01\x1f\x01\xb7\x00\x4d\x00\x5a\x00\x10\x01\x63\x00\x12\x01\x65\x00\x5f\x00\x60\x00\x61\x00\xb1\x00\xb2\x00\xb3\x00\x00\x01\x01\x01\x1c\x01\x03\x01\x04\x01\x16\x01\x06\x01\x07\x01\x08\x01\xed\x00\xee\x00\x1c\x01\x54\x00\x1e\x01\x1f\x01\x4d\x00\x10\x01\x11\x01\x12\x01\xf7\x00\xf8\x00\x02\x00\x03\x00\xfb\x00\xfc\x00\x47\x00\x00\x01\x01\x01\x1c\x01\x03\x01\x04\x01\x5a\x00\x06\x01\x07\x01\x08\x01\x02\x00\x03\x00\x14\x01\x15\x01\x16\x01\x69\x00\x6a\x00\x10\x01\x11\x01\x12\x01\x1c\x01\x80\x00\x13\x01\x14\x01\x15\x01\x16\x01\xda\x00\xdb\x00\xdc\x00\x1c\x01\xde\x00\x1c\x01\x56\x00\x1e\x01\x1f\x01\x00\x01\x01\x01\x22\x01\x54\x00\x04\x01\x56\x00\x06\x01\x6c\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x10\x01\x6c\x00\x12\x01\xb4\x00\x69\x00\x6a\x00\xb7\x00\x39\x00\x6c\x00\xba\x00\xbb\x00\x63\x00\x1c\x01\x65\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x67\x00\x49\x00\x69\x00\x63\x00\x6b\x00\x65\x00\x6d\x00\x4d\x00\x4e\x00\xf7\x00\xf8\x00\xb5\x00\xb6\x00\xfb\x00\xfc\x00\x76\x00\x6c\x00\x15\x01\x16\x01\x7a\x00\x5a\x00\x14\x01\x15\x01\x16\x01\x1c\x01\x5f\x00\x1e\x01\x1f\x01\x6c\x00\x1c\x01\x64\x00\x81\x00\xb5\x00\xb6\x00\x84\x00\x85\x00\x86\x00\x50\x00\x88\x00\x89\x00\xed\x00\xee\x00\x8c\x00\x8d\x00\x54\x00\x8f\x00\x90\x00\x91\x00\x1e\x01\x1f\x01\xf7\x00\xf8\x00\xb5\x00\xb6\x00\xfb\x00\xfc\x00\x14\x01\x15\x01\x16\x01\x72\x00\x84\x00\x85\x00\x86\x00\xdc\x00\x1c\x01\xde\x00\x63\x00\x8b\x00\x65\x00\x8d\x00\x4d\x00\x8f\x00\x90\x00\x91\x00\x14\x01\x15\x01\x16\x01\x72\x00\x13\x01\x14\x01\x15\x01\x16\x01\x1c\x01\x6c\x00\x6d\x00\xb7\x00\x63\x00\x1c\x01\x65\x00\x1e\x01\x1f\x01\x6e\x00\x6f\x00\x22\x01\x19\x01\x1a\x01\x1b\x01\x0d\x00\x1d\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x14\x01\x15\x01\x16\x01\xb4\x00\xb7\x00\x68\x00\xb7\x00\x39\x00\x1c\x01\xba\x00\xbb\x00\x9a\x00\x9b\x00\x9c\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xf2\x00\xf3\x00\x6a\x00\xf5\x00\x4a\x00\x6c\x00\x63\x00\xf9\x00\x65\x00\xfb\x00\xfc\x00\x6c\x00\xed\x00\x26\x01\x27\x01\x19\x01\x1a\x01\x1b\x01\x93\x00\x1d\x01\x5a\x00\x91\x00\x20\x01\x21\x01\x91\x00\x5f\x00\x60\x00\x25\x01\x57\x00\x58\x00\x59\x00\x00\x01\x01\x01\x13\x01\x03\x01\x04\x01\x16\x01\x06\x01\x07\x01\x08\x01\xed\x00\xee\x00\x1c\x01\x91\x00\x63\x00\x1f\x01\x65\x00\x10\x01\x11\x01\x12\x01\xf7\x00\xf8\x00\x07\x01\x08\x01\xfb\x00\xfc\x00\x6e\x00\x00\x01\x01\x01\x1c\x01\x03\x01\x04\x01\x6c\x00\x06\x01\x07\x01\x08\x01\x72\x00\x9f\x00\xa0\x00\xa1\x00\xaa\x00\xab\x00\xac\x00\x10\x01\x11\x01\x12\x01\x69\x00\x6a\x00\x13\x01\x14\x01\x15\x01\x16\x01\xaa\x00\xab\x00\xac\x00\x1c\x01\x63\x00\x1c\x01\x65\x00\x1e\x01\x1f\x01\xec\x00\xed\x00\x22\x01\x19\x01\x1a\x01\x1b\x01\x6a\x00\x1d\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\xaa\x00\xab\x00\xac\x00\xb4\x00\x9b\x00\x9c\x00\xb7\x00\x39\x00\x68\x00\xba\x00\xbb\x00\x04\x01\x05\x01\x06\x01\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x81\x00\x49\x00\x36\x00\x37\x00\x4f\x00\xaa\x00\xab\x00\xac\x00\x84\x00\x85\x00\x86\x00\x72\x00\x4d\x00\x58\x00\x8a\x00\x4d\x00\x5b\x00\x5c\x00\x8e\x00\x4d\x00\x5a\x00\x91\x00\x61\x00\x56\x00\x0d\x00\x5f\x00\xaa\x00\xab\x00\xac\x00\x71\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x68\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xed\x00\xee\x00\xa6\x00\x54\x00\x77\x00\x78\x00\x15\x00\x73\x00\x7b\x00\x7c\x00\xf7\x00\xf8\x00\x6c\x00\x6c\x00\xfb\x00\xfc\x00\xaa\x00\xab\x00\xac\x00\xb7\x00\x84\x00\x85\x00\x86\x00\xaa\x00\xab\x00\xac\x00\x73\x00\x8b\x00\x1f\x01\x8d\x00\x6c\x00\x8f\x00\x90\x00\x91\x00\xaa\x00\xab\x00\xac\x00\x28\x01\x13\x01\x14\x01\x15\x01\x16\x01\x6c\x00\x2e\x01\x73\x00\x73\x00\x6e\x00\x1c\x01\x6e\x00\x1e\x01\x1f\x01\x6c\x00\x6c\x00\x22\x01\x6c\x00\x6c\x00\x6a\x00\x64\x00\x61\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x71\x00\x0c\x00\x33\x00\xb4\x00\xb7\x00\x19\x00\xb7\x00\x39\x00\x5b\x00\xba\x00\xbb\x00\x50\x00\x72\x00\x72\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xfd\x00\x73\x00\x6c\x00\x6c\x00\x6c\x00\x00\x01\x01\x01\x6c\x00\x6c\x00\x04\x01\x6c\x00\x06\x01\x09\x01\x0a\x01\x6c\x00\x6c\x00\x68\x00\xff\x00\x00\x01\x01\x01\x5a\x00\x10\x01\x04\x01\x12\x01\x06\x01\x5f\x00\x4f\x00\x64\x00\x72\x00\x1a\x01\x1b\x01\x72\x00\x1d\x01\x1c\x01\x68\x00\x51\x00\x21\x01\x56\x00\x5b\x00\x5c\x00\xed\x00\xee\x00\x72\x00\x17\x00\x61\x00\x4f\x00\x72\x00\x56\x00\x54\x00\x64\x00\xf7\x00\xf8\x00\x6c\x00\x6c\x00\xfb\x00\xfc\x00\x72\x00\x00\x01\x01\x01\x4d\x00\x03\x01\x04\x01\x73\x00\x06\x01\x07\x01\x08\x01\x77\x00\x78\x00\x5a\x00\x50\x00\x7b\x00\x7c\x00\x51\x00\x10\x01\x11\x01\x12\x01\x4d\x00\x50\x00\x13\x01\x14\x01\x15\x01\x16\x01\x81\x00\x50\x00\x68\x00\x1c\x01\x4d\x00\x1c\x01\x4d\x00\x1e\x01\x1f\x01\x6c\x00\x91\x00\x22\x01\x6c\x00\x72\x00\xb7\x00\x54\x00\x5a\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\x02\x00\xc3\x00\xc4\x00\xb4\x00\xc6\x00\x50\x00\xb7\x00\x39\x00\x0a\x00\xba\x00\xbb\x00\x19\x00\x73\x00\x73\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x16\x00\x50\x00\x6c\x00\x51\x00\x39\x00\x19\x00\x1c\x00\x1d\x00\x1e\x00\x76\x00\x1a\x00\x80\x00\x4d\x00\x80\x00\x4d\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5a\x00\x4d\x00\x2c\x00\xed\x00\xee\x00\x5f\x00\x16\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0c\x00\xf7\x00\xf8\x00\x6b\x00\x71\x00\xfb\x00\xfc\x00\x80\x00\xed\x00\xee\x00\x5f\x00\x68\x00\x4d\x00\x4d\x00\x19\x00\x72\x00\x64\x00\x73\x00\xf7\x00\xf8\x00\xf5\x00\x50\x00\xfb\x00\xfc\x00\xf9\x00\x50\x00\xfb\x00\xfc\x00\x54\x00\x50\x00\x14\x01\x15\x01\x16\x01\x50\x00\x72\x00\x51\x00\x19\x00\x61\x00\x1c\x01\x19\x00\x1e\x01\x1f\x01\x56\x00\x07\x00\x22\x01\x51\x00\x13\x01\x14\x01\x15\x01\x16\x01\x13\x01\x4d\x00\x54\x00\x16\x01\x49\x00\x1c\x01\x7d\x00\x1e\x01\x1f\x01\x1c\x01\x61\x00\x22\x01\x1f\x01\x75\x00\x76\x00\x68\x00\x81\x00\x28\x01\x29\x01\x2a\x01\x2b\x01\xad\x00\xae\x00\xaf\x00\xb0\x00\xff\x00\x00\x01\x01\x01\xb4\x00\x71\x00\x04\x01\xb7\x00\x06\x01\x71\x00\xba\x00\xbb\x00\x64\x00\x4f\x00\x50\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xb4\x00\x54\x00\x68\x00\xb7\x00\x5b\x00\x5c\x00\xba\x00\xbb\x00\x6c\x00\x6c\x00\x61\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x6b\x00\x84\x00\x85\x00\x86\x00\x8a\x00\x19\x00\x19\x00\x89\x00\x8b\x00\x6c\x00\x8d\x00\x73\x00\x8f\x00\x90\x00\x91\x00\x77\x00\x78\x00\x8a\x00\x6c\x00\x7b\x00\x7c\x00\x71\x00\x5b\x00\xed\x00\xee\x00\x19\x00\x54\x00\xf6\x00\x71\x00\xf8\x00\x2d\x00\x51\x00\xfb\x00\xf7\x00\xf8\x00\x72\x00\x4d\x00\xfb\x00\xfc\x00\x19\x00\xed\x00\xee\x00\xff\x00\x00\x01\x01\x01\x53\x00\x4d\x00\x04\x01\x07\x00\x06\x01\xf7\x00\xf8\x00\xb7\x00\x89\x00\xfb\x00\xfc\x00\x13\x01\x07\x00\x19\x00\x16\x01\x61\x00\x13\x01\x14\x01\x15\x01\x16\x01\x1c\x01\x50\x00\x1e\x01\x1f\x01\x68\x00\x1c\x01\x80\x00\x1e\x01\x1f\x01\x4d\x00\x4d\x00\x22\x01\x19\x00\x13\x01\x14\x01\x15\x01\x16\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x4d\x00\x1c\x01\x4d\x00\x1e\x01\x1f\x01\x19\x00\x71\x00\x22\x01\x84\x00\x85\x00\x86\x00\x02\x00\x53\x00\x89\x00\x50\x00\x8b\x00\x56\x00\x8d\x00\x11\x00\x8f\x00\x90\x00\x91\x00\xff\x00\x00\x01\x01\x01\x23\x00\x1a\x00\x04\x01\x07\x00\x06\x01\x81\x00\x53\x00\x09\x00\x4f\x00\x6c\x00\x67\x00\x54\x00\x2e\x00\x6b\x00\x00\x01\x01\x01\x8a\x00\x03\x01\x04\x01\x6b\x00\x06\x01\x07\x01\x08\x01\x71\x00\x50\x00\x64\x00\x71\x00\x6b\x00\x47\x00\x6c\x00\x10\x01\x11\x01\x12\x01\x64\x00\xb7\x00\x64\x00\x84\x00\x85\x00\x86\x00\x53\x00\x50\x00\x89\x00\x1c\x01\x8b\x00\x6c\x00\x8d\x00\x72\x00\x8f\x00\x90\x00\x91\x00\x61\x00\x5a\x00\x8a\x00\x8a\x00\x72\x00\x84\x00\x85\x00\x86\x00\x6c\x00\x6c\x00\x89\x00\x72\x00\x8b\x00\x81\x00\x8d\x00\x02\x00\x8f\x00\x90\x00\x91\x00\x54\x00\x6c\x00\x6c\x00\x6c\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\x6b\x00\xf5\x00\x4d\x00\x54\x00\x89\x00\xf9\x00\x19\x00\xfb\x00\xfc\x00\xb7\x00\x84\x00\x85\x00\x86\x00\x53\x00\x07\x00\x89\x00\x6c\x00\x8b\x00\x6c\x00\x8d\x00\x19\x00\x8f\x00\x90\x00\x91\x00\x07\x00\x50\x00\x19\x00\x8a\x00\xb7\x00\x00\x01\x01\x01\x13\x01\x03\x01\x04\x01\x16\x01\x06\x01\x07\x01\x08\x01\x19\x00\x4f\x00\x1c\x01\x77\x00\x07\x00\x1f\x01\x85\x00\x10\x01\x11\x01\x12\x01\x77\x00\xff\x00\x00\x01\x01\x01\x30\x00\x25\x01\x04\x01\x38\x00\x06\x01\x1c\x01\xc7\x00\x54\x00\xe3\x00\xb7\x00\x84\x00\x85\x00\x86\x00\xe3\x00\x10\x01\x89\x00\x12\x01\x8b\x00\x41\x00\x8d\x00\x42\x00\x8f\x00\x90\x00\x91\x00\x7a\x00\xe3\x00\x1c\x01\x31\x00\x23\x01\x32\x00\x00\x01\x01\x01\x77\x00\x03\x01\x04\x01\x24\x01\x06\x01\x07\x01\x08\x01\x24\x01\x06\x01\x77\x00\x7b\x00\x7b\x00\x99\x00\x7f\x00\x10\x01\x11\x01\x12\x01\x00\x01\x01\x01\x4f\x00\x03\x01\x04\x01\x25\x01\x06\x01\x07\x01\x08\x01\x1c\x01\x54\x00\xc5\x00\xb7\x00\xd6\x00\x5b\x00\x5c\x00\x10\x01\x11\x01\x12\x01\xbd\x00\x61\x00\x16\x00\xff\x00\x00\x01\x01\x01\x16\x00\x30\x00\x04\x01\x1c\x01\x06\x01\x23\x01\x03\x00\x24\x01\x00\x01\x01\x01\x29\x01\x03\x01\x04\x01\x73\x00\x06\x01\x07\x01\x08\x01\x77\x00\x78\x00\x24\x01\xd6\x00\x7b\x00\x7c\x00\xde\x00\x10\x01\x11\x01\x12\x01\x63\x00\x84\x00\x85\x00\x86\x00\x87\x00\x50\x00\x89\x00\x4f\x00\x8b\x00\x1c\x01\x8d\x00\x41\x00\x8f\x00\x90\x00\x91\x00\x29\x01\xff\x00\x00\x01\x01\x01\x5b\x00\x5c\x00\x04\x01\x67\x00\x06\x01\x51\x00\x61\x00\x70\x00\x6d\x00\x23\x01\x23\x01\x23\x01\x78\x00\x23\x01\x00\x01\x01\x01\x1f\x01\x03\x01\x04\x01\x34\x00\x06\x01\x07\x01\x08\x01\x16\x00\x73\x00\x16\x00\x2c\x00\x20\x00\x77\x00\x78\x00\x10\x01\x11\x01\x12\x01\xb7\x00\x77\x00\x77\x00\x20\x00\x5e\x00\x33\x00\x43\x00\x59\x00\x66\x00\x1c\x01\x84\x00\x85\x00\x86\x00\x87\x00\x62\x00\x89\x00\x6b\x00\x8b\x00\x9e\x00\x8d\x00\x2c\x00\x8f\x00\x90\x00\x91\x00\x23\x01\x0e\x00\x20\x00\x95\x00\x96\x00\x20\x00\xbd\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\x6b\x00\xf5\x00\xde\x00\x9e\x00\x42\x00\xf9\x00\xac\x00\xfb\x00\xfc\x00\x9c\x00\x46\x00\x24\x01\x17\x00\x17\x00\x35\x00\x47\x00\x54\x00\x23\x01\x4c\x00\xed\x00\x23\x01\x4b\x00\xa5\x00\x1c\x00\x23\x01\x1c\x00\xb7\x00\x0b\x00\x24\x01\x26\x00\x24\x01\x13\x01\x24\x01\x23\x01\x16\x01\x52\x00\x29\x01\x23\x01\x00\x01\x01\x01\x1c\x01\x03\x01\x04\x01\x1f\x01\x06\x01\x07\x01\x08\x01\x54\x00\x50\x00\x24\x01\x84\x00\x85\x00\x86\x00\x23\x01\x10\x01\x11\x01\x12\x01\x8b\x00\x16\x00\x8d\x00\x23\x01\x8f\x00\x90\x00\x91\x00\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x52\x00\x23\x01\x20\x01\x21\x01\x29\x01\x16\x00\x20\x00\x25\x01\x20\x00\x24\x01\x9e\x00\x9e\x00\xed\x00\x84\x00\x85\x00\x86\x00\x87\x00\x24\x01\x89\x00\x17\x00\x8b\x00\x24\x01\x8d\x00\x17\x00\x8f\x00\x90\x00\x91\x00\x24\x01\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xb7\x00\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xff\xff\xf5\x00\xff\xff\xff\xff\x1c\x01\xf9\x00\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x13\x01\xff\xff\xff\xff\x16\x01\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x1d\x01\xff\xff\x1f\x01\xff\xff\x21\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xb7\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xf4\x00\xf5\x00\xff\xff\xff\xff\xff\xff\xf9\x00\x1c\x01\xfb\x00\xfc\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\x13\x01\xff\xff\xff\xff\x16\x01\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\x1f\x01\x80\x00\x81\x00\x25\x01\xed\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\x1c\x01\xff\xff\xff\xff\x61\x00\xff\xff\xb7\x00\x80\x00\xff\xff\xff\xff\x25\x01\x84\x00\x85\x00\x86\x00\x87\x00\x6c\x00\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\x72\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\xed\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x4f\x00\x50\x00\x51\x00\xb7\x00\xff\xff\x54\x00\x73\x00\x10\x01\x11\x01\x12\x01\x77\x00\x78\x00\x5b\x00\x5c\x00\x7b\x00\x7c\x00\x80\x00\xff\xff\x61\x00\x1c\x01\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xed\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x1c\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\x59\x00\x80\x00\x5b\x00\x1c\x01\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xf7\x00\xf8\x00\xff\xff\xb7\x00\xfb\x00\xfc\x00\x10\x01\x11\x01\x12\x01\xff\xff\x80\x00\xff\xff\xff\xff\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x80\x00\xff\xff\xff\xff\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xed\x00\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x80\x00\xff\xff\xb7\x00\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xed\x00\x73\x00\x10\x01\x11\x01\x12\x01\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x80\x00\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xed\x00\x8f\x00\x90\x00\x91\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x81\x00\xff\xff\x1c\x01\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xf6\x00\xff\xff\xf8\x00\xff\xff\xff\xff\xfb\x00\xff\xff\xff\xff\xfe\x00\xff\xff\x81\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\x0a\x01\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x13\x01\xff\xff\xed\x00\x16\x01\xff\xff\xff\xff\xb7\x00\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x10\x01\x11\x01\x12\x01\x81\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\x1c\x01\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xed\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\x81\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\x1c\x01\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x10\x01\x11\x01\x12\x01\x81\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\x1c\x01\xfe\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x01\xff\xff\x0d\x01\x0e\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\x17\x01\xff\xff\x19\x01\x1a\x01\x1b\x01\xff\xff\x1d\x01\xff\xff\xff\xff\x20\x01\x21\x01\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\x00\x01\x01\x01\x22\x01\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x10\x01\x11\x01\x12\x01\xfe\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\x17\x01\xff\xff\x19\x01\x1a\x01\x1b\x01\xff\xff\x1d\x01\xff\xff\xff\xff\x20\x01\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x10\x01\x11\x01\x12\x01\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\xff\xff\x14\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\x14\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\x14\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x4f\x00\xff\xff\x51\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\x61\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\x4f\x00\xff\xff\x73\x00\x52\x00\xff\xff\x54\x00\x77\x00\x78\x00\xff\xff\x58\x00\x7b\x00\x7c\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\x0e\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xfe\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x17\x01\xff\xff\x19\x01\x1a\x01\x1b\x01\x58\x00\x1d\x01\xff\xff\x5b\x00\x20\x01\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x17\x01\x54\x00\x19\x01\x1a\x01\x1b\x01\x58\x00\x1d\x01\xff\xff\x5b\x00\x20\x01\x21\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x52\x00\x93\x00\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\xff\xff\x1c\x01\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\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\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\xff\xff\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\xff\xff\x8d\x00\x52\x00\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xb7\x00\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\x1c\x01\x58\x00\x84\x00\x85\x00\x86\x00\x5c\x00\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xb7\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xed\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x1c\x01\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xb7\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xed\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x1c\x01\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xb7\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xed\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x10\x01\x11\x01\x12\x01\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x67\x00\x1c\x01\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\x70\x00\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xb7\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x1c\x01\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x0a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xed\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\x59\x00\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x40\x00\x41\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\x6e\x00\xb7\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\x40\x00\x41\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\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\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\x7b\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\x4f\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\xff\xff\x7a\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xed\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x16\x00\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\xb7\x00\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\xff\xff\xff\xff\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xed\x00\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xed\x00\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xed\x00\x8f\x00\x90\x00\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\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\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xed\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\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xed\x00\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x00\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1c\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x00\xff\xff\xed\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\x9d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xb7\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\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\xed\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x00\x01\x01\x01\xb7\x00\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x9d\x00\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\x1c\x01\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\x9d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xb7\x00\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1c\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xed\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xb7\x00\x8b\x00\x1c\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\xed\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x00\x01\x01\x01\xb7\x00\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xed\x00\x8b\x00\x1c\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\x1c\x01\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\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\xed\x00\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xb7\x00\x8f\x00\x90\x00\x91\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\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xed\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\x1c\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1c\x01\x89\x00\xff\xff\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xed\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xb7\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\x1c\x01\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xed\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xd7\x00\xd8\x00\xd9\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xdf\x00\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xb7\x00\xfb\x00\xfc\x00\x1c\x01\x84\x00\x85\x00\x86\x00\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\x23\x01\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xed\x00\xb7\x00\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\xff\xff\x89\x00\xed\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\x02\x00\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xb7\x00\xff\xff\x1c\x01\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xed\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\x07\x01\x08\x01\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x80\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x80\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\x77\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x80\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x02\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\x73\x00\xff\xff\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x01\x00\x02\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\x73\x00\xff\xff\x75\x00\x76\x00\x77\x00\x78\x00\xff\xff\x7a\x00\xff\xff\x7c\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xb7\x00\x02\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0a\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xe1\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x02\x00\x1e\x01\x1f\x01\xff\xff\x6b\x00\x22\x01\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x13\x00\x79\x00\x7a\x00\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x02\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\x0a\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x16\x00\xff\xff\x7a\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x0a\x00\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x16\x00\xff\xff\x7a\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\x16\x00\xff\xff\x18\x00\x7a\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\xff\xff\xff\xff\x1a\x00\x79\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\x6b\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\x75\x00\xff\xff\xff\xff\x1a\x00\x79\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x02\x00\xff\xff\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\x0a\x00\xff\xff\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\x77\x00\x78\x00\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\x76\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\x76\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x0a\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x75\x00\x76\x00\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x02\x00\xb7\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x0a\x00\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xe1\x00\xe2\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\xff\xff\xff\xff\xff\xff\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\x63\x00\x0a\x00\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\x16\x00\xff\xff\x72\x00\xff\xff\x1a\x00\x75\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x75\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\x75\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x75\x00\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\x6b\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x02\x00\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0a\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x6b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x16\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\x6b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xb7\x00\xb8\x00\xb9\x00\x75\x00\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xcd\x00\xce\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xcc\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xcc\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xfe\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\x0c\x01\x0d\x01\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\x18\x01\x19\x01\xff\xff\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcf\x00\xd0\x00\xd1\x00\xd2\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\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xd0\x00\xd1\x00\xd2\x00\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xe5\x00\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xe4\x00\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xe4\x00\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xd4\x00\xd5\x00\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xd7\x00\xd8\x00\xd9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xd4\x00\xd5\x00\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xd7\x00\xd8\x00\xd9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xdc\x00\xdd\x00\xde\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xd2\x00\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xe0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xff\xff\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xd9\x00\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xdf\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\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xb8\x00\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xb7\x00\xff\xff\xb9\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xb7\x00\xff\xff\xfb\x00\xfc\x00\xbb\x00\xbc\x00\xff\xff\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\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\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xf7\x00\xf8\x00\xbb\x00\xff\xff\xfb\x00\xfc\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xfb\x00\xfc\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\x14\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x22\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++happyTable :: HappyAddr+happyTable = HappyA# "\x00\x00\x6e\x00\x86\x05\x9e\x02\x41\x05\x42\x05\xa6\x04\x9e\x04\x88\x05\x6c\x03\x99\x04\x96\x04\x95\x04\x96\x04\x97\x04\x0d\x01\x97\x04\x0e\x01\x0d\x04\x25\x05\x3e\x05\x3f\x05\x97\x04\x0f\x01\x10\x01\x11\x01\x2c\x00\x2d\x00\x5b\x05\x12\x01\x1b\x02\x1c\x02\x1d\x02\x6c\x05\x2e\x00\x8a\x05\x2f\x00\x32\x03\x8b\x05\xb7\x04\x1c\x02\x1d\x02\xb6\x04\x1c\x02\xdc\x03\x21\x05\xb7\x04\x1c\x02\x1d\x02\xb7\x04\x1c\x02\x1d\x02\x5e\x04\x4b\x03\x9b\x04\x9c\x04\x9d\x04\x9e\x04\x65\x05\x9c\x04\x9d\x04\x9e\x04\x73\x05\x69\x05\x9c\x04\x9d\x04\x9e\x04\x52\x05\xfa\x02\x83\x05\x84\x05\x9e\x04\x30\x04\x40\x03\x31\x05\x9e\x04\x92\x02\x93\x02\x26\x05\x9e\x04\x19\x02\x3e\x03\x44\x03\x45\x03\xc1\xff\x55\x03\x90\x05\x92\x04\xf6\x01\xf4\x01\xf5\x01\xf6\x01\x6d\x03\x19\x02\x8a\x02\x9b\x03\xf9\x04\x99\x04\xc1\xff\x92\x02\x93\x02\x0e\x04\x6a\x02\xbb\x02\x7c\x04\x7d\x04\x7d\x01\xf5\x04\x67\x03\x92\x03\x7b\x05\x5c\x05\x70\x03\xcd\xfc\x4a\xfe\xc0\x02\x6d\x05\xc1\xff\x64\x03\xd5\x01\x58\x01\x0e\x02\xa7\x04\x9b\x02\x48\x00\xbc\xff\xc1\xff\xa8\x04\xa9\x04\x35\x05\x36\x05\x37\x05\x38\x05\xa9\x04\xcd\xfc\xe0\x04\x85\x05\x38\x05\xa9\x04\x36\x04\x37\x04\xb2\x01\xfb\x03\x0c\x03\xbc\x02\x5b\x04\xbe\x02\x7f\x00\x7c\x05\x33\x00\xd1\x02\x07\x01\xb3\x01\xeb\x01\x0f\x02\x6e\x01\xcc\x04\x71\x00\x23\x01\xc1\xff\x99\x04\x08\x01\x25\x03\x26\x03\x32\x00\x2c\x01\x2d\x01\xdf\x02\x72\x03\x07\x01\x22\x01\x6b\x02\x71\x00\x23\x01\x59\x01\x57\x04\x37\x04\xc0\x01\x14\x01\x0d\x03\x0d\x01\x33\x00\x1a\x02\xf9\x02\x8b\x02\x8b\x02\x8c\x02\x07\x01\x89\x00\x59\x01\x65\x03\xcd\xfc\x7b\x01\x26\x01\xf7\x01\x1a\x02\x24\x01\xbf\x02\x9f\x02\x25\x01\x7e\x04\x56\x03\x33\x00\x46\x03\xf6\x04\x11\x00\x25\x01\xbc\xff\x26\x01\x92\x03\xa0\x02\xa1\x02\x11\x00\x9b\xfe\x07\x01\xf7\x01\x33\x00\x95\x02\xf7\x01\x73\x03\xde\x02\xf8\x01\x46\x03\xdf\x02\xf8\x01\x25\x01\xf7\x01\xde\x01\x78\x00\x34\x01\x79\x00\x11\x00\x6e\x03\x46\x03\xa2\x02\xf7\x01\x25\x01\xf7\x01\x29\x04\x08\x03\x94\x02\x6e\x03\x11\x00\x7e\x04\x33\x00\xf7\x01\xab\x02\x29\x02\x6f\x00\x70\x00\xf7\x01\x6e\x03\x71\x00\x72\x00\xfb\x02\x73\x00\x6e\x03\x03\x03\x5f\x04\xfb\x02\x11\x00\x08\x01\x19\x02\x3f\x03\x53\x05\x11\x00\x25\x01\x9f\x04\x4c\x00\xa0\x04\xa1\x04\x74\x00\x11\x00\x39\x03\x4f\x01\x09\x03\xba\x04\x0e\x00\x0f\x00\x10\x00\x75\x00\x40\x05\x76\x00\x77\x00\x78\x00\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x43\x05\x5f\x04\x04\x03\x43\x05\x30\x00\x33\x00\x30\x00\x30\x00\x36\x00\x40\x05\xfa\x04\x4c\x00\x30\x00\x38\x04\x30\x00\x1e\x02\x30\x00\xf7\x02\xbb\x04\x11\x00\x4c\x00\x2a\x01\x2b\x01\x3a\x03\x1e\x02\x34\x00\x9f\x04\x1e\x02\xa0\x04\xa1\x04\x9f\x04\x1e\x02\xa0\x04\xa1\x04\x1e\x02\x9f\x04\x3f\x03\xa0\x04\xa1\x04\x25\x01\x9f\x04\x19\x02\xa0\x04\xa1\x04\x9f\x04\x11\x00\xa0\x04\xa1\x04\x9f\x04\x38\x04\xa0\x04\xa1\x04\xaa\x04\xa2\x02\xab\x04\x11\x00\x46\x00\xaa\x04\x19\x02\xab\x04\x19\x02\x46\x00\xaa\x04\xb7\x01\xab\x04\xb8\x01\x46\x00\xfd\x01\xcf\x03\x4b\x00\xac\x04\x0f\x00\x10\x00\x1a\x02\xff\xff\xac\x04\x0f\x00\x10\x00\x11\x00\x4c\x00\xac\x04\x0f\x00\x10\x00\x11\x00\x1b\x02\xcc\x00\x19\x02\x19\x02\x11\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xfd\x01\x19\x02\x4b\x00\x35\x01\x36\x01\x71\x00\x23\x01\x2a\x02\x2a\x02\x8f\x03\x25\x01\x25\x01\x4c\x00\xe7\x00\xfe\x04\xfc\x04\x11\x00\x11\x00\x50\x01\x7f\x00\xe8\x00\xe9\x00\x16\x01\x2e\x01\x2f\x01\xea\x00\xfb\x01\xfc\x01\x3b\x01\x8e\x03\xcd\x00\x51\x01\x37\x01\x52\x01\x53\x01\x14\x01\x89\x04\x8a\x04\x11\x00\x19\x02\x6a\x01\x26\x01\x15\x01\x75\x00\x3c\x01\x76\x00\x77\x00\x78\x00\x6c\x01\x79\x00\x1a\x02\xf6\x03\x7c\x00\x7d\x00\x6d\x01\x15\x01\xeb\x00\x2c\x01\x2d\x01\xd1\x02\x89\x00\xb7\x03\x22\x01\x8f\x03\x71\x00\x23\x01\x8e\x02\x1a\x02\x3d\x04\x1a\x02\x6d\x01\x3e\x02\x19\x02\x41\x02\x36\x00\x37\x00\x38\x00\x06\x03\x8a\x03\x11\x00\x88\x03\xee\x02\x42\x03\x3d\x01\x84\x02\x3d\x00\x3e\x00\x3f\x00\x24\x01\x99\xfe\x85\x02\x25\x01\x99\xfe\x3e\x04\x6b\x03\x1a\x02\x1a\x02\x11\x00\x9b\xfe\x80\x02\x26\x01\x3f\x02\x07\x03\x1a\x02\x48\x01\x81\x02\xdb\x04\xd1\x04\xec\x00\xed\x00\xee\x00\x36\x00\x37\x00\x38\x00\xb6\x04\xef\x00\x43\x02\x78\x00\x8c\x00\x79\x00\x86\x02\xf0\x00\xd0\x00\x00\x02\x3f\x00\x40\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\xcc\x00\x49\x01\x4a\x01\x82\x02\x96\x03\xe4\x00\xe5\x00\xe6\x00\xff\xff\x1a\x02\x6e\x01\x36\x01\x71\x00\x23\x01\x08\x01\xfd\x01\xc0\x01\x4b\x00\x30\x01\x2d\x01\x8a\x03\xe7\x00\x0c\x02\x22\x01\x0a\x02\x71\x00\x23\x01\x4c\x00\xe8\x00\xe9\x00\x40\x00\x38\x02\xbe\x03\xea\x00\x36\x00\x37\x00\x38\x00\x0b\x02\xcd\x00\x0b\x02\x9c\x00\x9d\x00\x1a\x02\xf0\x04\x74\x05\x27\x02\xfc\x01\x1a\x05\x26\x01\x24\x01\x9e\x00\x70\x00\x25\x01\x61\x05\x71\x00\x72\x00\x8f\x03\xfc\x01\x11\x00\x39\x02\x09\x02\x26\x01\x6a\x01\x15\x01\xeb\x00\x3a\x02\x42\x00\x43\x00\x75\x05\x44\x00\x45\x00\xef\x04\x46\x00\x47\x00\x48\x00\x67\x03\xfc\x01\xff\xff\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x49\x00\x4a\x00\x4b\x00\x40\x00\xcf\x02\x11\x00\x03\x02\x7a\x00\x7b\x00\x15\x01\x6d\x01\xa0\x00\x4c\x00\x6e\x01\x6f\x01\x71\x00\x23\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x42\x00\x43\x00\xa1\xfe\x44\x00\x45\x00\xa1\xfe\x46\x00\x47\x00\x48\x00\xe5\x03\x60\x02\x48\x01\x23\x02\xec\x00\xed\x00\xee\x00\x49\x00\x4a\x00\x4b\x00\x00\x02\xef\x00\xf9\x03\xfb\x01\x8c\x00\xcc\x00\x1b\x02\xf0\x00\xd0\x00\x4c\x00\x2f\x02\x26\x01\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\xfb\x04\xfc\x04\x30\x02\x49\x01\x4a\x01\x34\x03\x33\x05\x62\x04\x63\x04\xfa\x01\x6e\x01\x78\x03\x71\x00\x23\x01\xfa\x03\x61\x02\x0f\x00\x10\x00\x42\x00\x43\x00\xea\x00\x0b\x02\x45\x00\x11\x00\x46\x00\xcd\x00\xfd\x01\x32\x05\x4b\x00\x56\x00\x64\x04\x69\x04\x1c\x03\x58\x00\x49\x00\x3f\x04\x4b\x00\xfd\x01\x4c\x00\x4b\x00\x9c\x00\x9d\x00\x0b\x02\x17\x05\xfc\x01\x40\x04\x4c\x00\x7f\x00\x26\x01\x4c\x00\x9e\x00\x70\x00\x1d\x03\x1e\x03\x71\x00\x72\x00\xfd\x01\xb6\x03\x4b\x00\x13\x02\x36\x00\x37\x00\x38\x00\x07\x01\x89\x03\x09\x01\x0a\x01\xee\x02\x4c\x00\x3d\x01\xb7\x03\x3d\x00\x3e\x00\x3f\x00\x14\x02\x15\x02\x6c\x01\x8a\x03\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x6d\x01\xa9\x01\xe2\x01\x51\x02\x46\x00\x11\x00\x89\x00\x7a\x00\x7b\x00\x36\x02\x8c\x00\xa0\x00\x36\x00\x37\x00\x38\x00\xff\xff\xe3\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\x66\x04\x04\x02\x4c\x00\x7d\x05\xef\x00\x40\x00\x92\xfd\x8c\x00\xcc\x00\x7f\x00\xaf\x02\xd0\x00\x26\x02\x7e\x05\x4b\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x80\x00\x81\x00\xc6\x01\x4c\x00\x30\x01\x2d\x01\x82\x00\x62\x04\x63\x04\x22\x01\xc5\x01\x71\x00\x23\x01\x87\x03\xda\x04\x80\x00\x81\x00\x6c\x01\x40\x00\xff\xff\xea\x00\x82\x00\x20\x04\x6d\x01\x4b\x00\xcd\x00\x88\x03\xdb\x04\x88\x00\x89\x00\x64\x04\x65\x04\x8b\x00\x8c\x00\x4c\x00\x24\x01\xc4\x01\xfd\x01\x25\x01\x4b\x00\x9c\x00\x9d\x00\x63\x05\x88\x00\x11\x00\xb4\x01\xd0\x04\x26\x01\xb1\x01\x4c\x00\x9e\x00\x70\x00\x4c\x00\xb5\x04\x71\x00\x72\x00\x35\x02\x42\x00\x43\x00\xd1\x04\x44\x00\x45\x00\x36\x02\x46\x00\x47\x00\x48\x00\xb6\x04\xce\x04\xca\x04\xcb\x04\x80\x05\xec\x02\x86\x01\x49\x00\x4a\x00\x4b\x00\x81\x05\xff\xff\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x62\x00\xc9\x04\x02\x02\x4c\x00\x65\x00\x11\x00\x9b\xfe\x7a\x00\x7b\x00\x42\x00\x43\x00\xa0\x00\x62\x00\x45\x00\x83\x01\x46\x00\x65\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\x66\x04\x49\x00\x19\xfd\x4b\x00\xef\x00\x11\x02\xf7\x01\x8c\x00\xcc\x00\x12\x02\xaf\x02\xd0\x00\x2c\x02\x4c\x00\x7b\x01\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\xf8\x04\xed\x02\xff\xff\x7f\x00\x84\x01\xa1\x01\x36\x00\x37\x00\x38\x00\x6d\x01\x81\x01\xec\x02\x82\x01\x8a\x03\x60\x05\x80\x00\x81\x00\x80\x00\x81\x00\x49\x05\xea\x00\x82\x00\x62\x00\x82\x00\x7f\x00\xcd\x00\x65\x00\x61\x05\x4b\x01\xf7\x01\x6e\x01\xcc\x04\x71\x00\x23\x01\xb4\x02\xc5\x04\x80\x00\x81\x00\x4c\x01\x56\x01\x9c\x00\x9d\x00\x82\x00\x88\x00\x89\x00\x88\x00\x43\x03\x8b\x00\x8c\x00\x8b\x00\x9e\x00\x70\x00\x11\x00\x6c\x01\x71\x00\x72\x00\xb7\x01\x40\x00\xb8\x01\x6d\x01\x36\x00\x37\x00\x38\x00\x34\x01\x88\x00\x89\x00\x1e\x01\xee\x02\x26\x01\x3d\x01\x83\x00\x3d\x00\x3e\x00\x3f\x00\x39\x01\xff\xff\x85\x00\xf7\x01\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x56\x04\xcd\x04\x1b\x01\x87\x00\x20\x03\x11\x00\x11\x00\x7a\x00\x7b\x00\x25\x03\x26\x03\xa0\x00\x36\x00\x37\x00\x38\x00\x21\x03\x22\x03\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\xae\x02\x5d\x02\x19\x01\x2e\x04\xef\x00\x40\x00\x25\x01\x8c\x00\xcc\x00\x9b\x02\xaf\x02\xd0\x00\x11\x00\x6d\x01\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x4a\x05\xff\xff\x55\x00\x42\x00\x43\x00\x43\x02\x78\x00\x45\x00\x79\x00\x46\x00\xea\x02\x9d\x02\xc0\x02\x45\x00\x57\x00\x46\x00\xd5\x01\x18\x01\x40\x00\x49\x00\xea\x00\x4b\x00\x83\x00\xfe\x02\x20\x03\xcd\x00\x39\x01\xff\x02\x85\x00\x83\x00\x17\x02\x4c\x00\xcd\xfc\x2d\x05\xac\x02\x85\x00\xa2\x02\x87\x00\xb5\x02\xb2\x02\xb3\x02\x9d\x00\x63\x00\x64\x00\x87\x00\x54\x02\x66\x00\x67\x00\x8a\x00\x36\x02\x9e\x00\x70\x00\x50\x03\x51\x03\x71\x00\x72\x00\x07\x01\x42\x00\x43\x00\x19\x03\x44\x00\x45\x00\x3b\x02\x46\x00\x47\x00\x48\x00\x36\x02\xc9\x04\xca\x04\xcb\x04\x17\x03\xd4\x01\x7d\x00\x49\x00\x4a\x00\x4b\x00\xd5\x01\x15\x03\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x92\x01\x2d\x05\x93\x01\x4c\x00\x45\x00\x11\x00\x46\x00\x7a\x00\x7b\x00\x42\x00\x43\x00\xa0\x00\x11\x02\x45\x00\x13\x03\x46\x00\x12\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\xae\x02\x49\x00\x2e\x03\x4b\x00\xef\x00\x2a\x03\x2f\x03\x8c\x00\xcc\x00\x2b\x03\xaf\x02\xd0\x00\x81\x01\x4c\x00\x82\x01\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x62\x00\xd1\x04\x02\x04\xdf\x03\x6c\x04\x25\x01\x02\x03\xe0\x03\x36\x00\x37\x00\x38\x00\x11\x00\x5e\x02\x5f\x02\x60\x02\x0e\x00\x0f\x00\x10\x00\x76\x05\x0a\x03\xea\x00\x1a\x05\xfa\x02\x11\x00\x11\x02\xcd\x00\x6d\x04\x73\x04\x12\x02\xf0\x02\x6e\x01\xcc\x04\x71\x00\x23\x01\x36\x00\x37\x00\x38\x00\x02\x02\xb1\x02\xb2\x02\xb3\x02\x9d\x00\x11\x05\x12\x05\xdf\x03\x3d\x00\x3e\x00\x3f\x00\x93\x04\x13\x05\x9e\x00\x70\x00\x25\x03\x26\x03\x71\x00\x72\x00\x61\x02\x0f\x00\x10\x00\x40\x00\x36\x00\x37\x00\x38\x00\x7a\x02\x11\x00\x7b\x02\xdf\x03\xd2\x04\x26\x01\x3d\x01\x4d\x05\x3d\x00\x3e\x00\x3f\x00\x77\x01\x0f\x00\x10\x00\xf7\x01\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x11\x00\xcd\x04\xdf\x03\x40\x00\xe9\x02\x11\x00\x48\x05\x7a\x00\x7b\x00\x0a\x05\x0b\x05\xa0\x00\x36\x00\x37\x00\x38\x00\x0a\x05\x59\x05\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\x6f\x04\x49\x05\xdf\x03\xe8\x02\xef\x00\x40\x00\x8f\x05\x8c\x00\xcc\x00\xe5\x02\xaf\x02\xd0\x00\x15\x03\xdb\x02\xdc\x02\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x43\x01\x44\x01\x45\x01\x46\x01\x6c\x04\x42\x00\x43\x00\xd0\x01\x10\x00\x45\x00\x27\x04\x46\x00\x28\x04\x1f\x04\x11\x00\x20\x04\xd1\x01\x7b\x00\x40\x00\xe7\x02\xea\x00\x49\x00\x81\x01\x4b\x00\x82\x01\xcd\x00\x6d\x04\x6e\x04\xda\x02\xdb\x02\xdc\x02\x42\x00\x43\x00\x4c\x00\x44\x00\x45\x00\x41\x02\x46\x00\x47\x00\x48\x00\x9c\x00\x9d\x00\x11\x00\xe2\x02\xd1\x01\x7b\x00\xe6\x02\x49\x00\x4a\x00\x4b\x00\x9e\x00\x70\x00\x09\x02\x07\x02\x71\x00\x72\x00\x59\x01\x42\x00\x43\x00\x4c\x00\x44\x00\x45\x00\xe0\x02\x46\x00\x47\x00\x48\x00\x06\x02\x07\x02\x1e\x01\x0f\x00\x10\x00\x7e\x01\xba\x01\x49\x00\x4a\x00\x4b\x00\x11\x00\xd2\x02\xd1\x00\x9f\x00\x0f\x00\xd2\x00\xee\x03\xef\x03\xf0\x03\x4c\x00\xbe\x01\x11\x00\xd1\x02\x7a\x00\x7b\x00\x42\x00\x43\x00\xa0\x00\xc0\x01\x45\x00\xf2\x03\x46\x00\xce\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\x6f\x04\x49\x00\x53\x02\x4b\x00\xef\x00\x7e\x01\x7f\x01\x8c\x00\xcc\x00\xcc\x02\xaf\x02\xd0\x00\xdb\x03\x4c\x00\xdc\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x8a\x01\x07\x05\x8b\x01\x78\x04\x8c\x01\x79\x04\x8d\x01\x62\x04\x63\x04\x2b\x05\x70\x00\x7d\x01\x79\x01\x71\x00\x72\x00\x62\x00\x05\xfd\xc7\x02\x10\x00\x65\x00\xea\x00\x1c\x01\x0f\x00\x10\x00\x11\x00\xcd\x00\xd1\x01\x7b\x00\x52\x02\x11\x00\x03\x05\xa4\x02\x7b\x01\x79\x01\x36\x00\x37\x00\x38\x00\xc6\x02\xa5\x02\xa6\x02\x9c\x00\x9d\x00\xa7\x02\xa8\x02\xc3\x02\x3d\x00\x3e\x00\x3f\x00\x7a\x00\x7b\x00\x9e\x00\x70\x00\x78\x01\x79\x01\x71\x00\x72\x00\xbc\x02\x0f\x00\x10\x00\xc7\x02\x36\x00\x37\x00\x38\x00\x66\x02\x11\x00\xbe\x01\x5a\x04\xee\x02\x5b\x04\x3d\x01\xc4\x02\x3d\x00\x3e\x00\x3f\x00\xb9\x02\x0f\x00\x10\x00\xc2\x02\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x11\x00\x31\x01\x32\x01\x40\x00\xed\x04\x11\x00\xee\x04\x7a\x00\x7b\x00\xff\x02\x00\x03\xa0\x00\xd3\x01\xa1\x01\x78\x00\x6f\x02\x79\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\x66\x04\xb6\x02\x0f\x00\x10\x00\xef\x00\x40\x00\xf4\x01\x8c\x00\xcc\x00\x11\x00\xaf\x02\xd0\x00\x5c\x03\x5d\x03\x5e\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x7c\x03\x74\x01\xf2\x01\x75\x01\x6c\x04\x9a\x02\xe2\x04\x22\x01\xe3\x04\x71\x00\x23\x01\x99\x02\xa9\x02\x74\x03\x75\x03\xd3\x01\xa1\x01\x78\x00\x98\x02\x79\x00\xea\x00\x97\x02\xd4\x01\x7d\x00\x92\x02\xcd\x00\x0b\x05\xd5\x01\x51\x03\x52\x03\x53\x03\x42\x00\x43\x00\x24\x01\x44\x00\x45\x00\x25\x01\x46\x00\x47\x00\x48\x00\x9c\x00\x9d\x00\x11\x00\x90\x02\xa5\x04\x26\x01\xa6\x04\x49\x00\x4a\x00\x4b\x00\x9e\x00\x70\x00\x9b\x02\x48\x00\x71\x00\x72\x00\x8a\x02\x42\x00\x43\x00\x4c\x00\x44\x00\x45\x00\x87\x02\x46\x00\x47\x00\x48\x00\x7e\x02\x50\x05\xca\x04\xcb\x04\x11\x04\x12\x04\x13\x04\x49\x00\x4a\x00\x4b\x00\x7e\x01\x1a\x04\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x7f\x04\x12\x04\x13\x04\x4c\x00\xed\x04\x11\x00\xee\x04\x7a\x00\x7b\x00\x06\x04\x07\x04\xa0\x00\xd3\x01\xa1\x01\x78\x00\x83\x02\x79\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\x6f\x04\x79\x04\x12\x04\x13\x04\xef\x00\x6a\x04\x5e\x03\x8c\x00\xcc\x00\x7f\x02\xaf\x02\xd0\x00\xc6\x04\xc7\x04\x46\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x77\x02\x02\x05\xf2\x04\xf3\x04\x28\x05\xc2\x04\x12\x04\x13\x04\x36\x00\x37\x00\x38\x00\x7e\x02\x76\x02\x29\x05\x18\x05\x75\x02\x80\x00\x81\x00\x19\x05\x74\x02\xea\x00\x1a\x05\x82\x00\x70\x02\x6f\x02\xcd\x00\x6e\x05\x12\x04\x13\x04\x6e\x02\x6e\x01\xcc\x04\x71\x00\x23\x01\xe6\x04\xf2\x02\xf3\x02\xf4\x02\xf5\x02\xf6\x02\x9c\x00\x9d\x00\x1b\x05\xc0\x01\x88\x00\x2a\x05\x66\x02\x56\x02\x8b\x00\x2b\x05\x9e\x00\x70\x00\x53\x02\x52\x02\x71\x00\x72\x00\x92\x05\x12\x04\x13\x04\x40\x00\x36\x00\x37\x00\x38\x00\x91\x05\x12\x04\x13\x04\x55\x02\xee\x02\x26\x01\x3d\x01\x50\x02\x3d\x00\x3e\x00\x3f\x00\x95\x05\x12\x04\x13\x04\xf7\x01\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x4f\x02\xcd\x04\x41\x02\x40\x02\x3d\x02\x11\x00\x3c\x02\x7a\x00\x7b\x00\x37\x02\x34\x02\xa0\x00\x33\x02\x32\x02\x31\x02\x2e\x02\x29\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\xae\x02\x17\x02\x0d\x01\x09\x02\xef\x00\x40\x00\xd3\x03\x8c\x00\xcc\x00\xd2\x03\xaf\x02\xd0\x00\xd1\x03\xce\x03\xc5\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x9f\x02\xc6\x03\xc4\x03\xe8\xfc\x04\xfd\x42\x00\x43\x00\xf0\xfc\xef\xfc\x45\x00\x03\xfd\x46\x00\xfd\x03\xa1\x02\xe9\xfc\xea\xfc\xc3\x03\x13\x03\x87\x01\x43\x00\xea\x00\x49\x00\x45\x00\x4b\x00\x46\x00\xcd\x00\x7f\x00\xc2\x03\x3f\x02\xde\x01\x78\x00\xc1\x03\x79\x00\x4c\x00\xe5\x04\xc0\x03\xa2\x02\xbd\x03\x80\x00\x81\x00\x9c\x00\x9d\x00\xbc\x03\xbb\x03\x82\x00\xb4\x03\x6d\x01\xaa\x03\xcb\x02\x95\x03\x9e\x00\x70\x00\x37\x02\x33\x02\x71\x00\x72\x00\x94\x03\x42\x00\x43\x00\x86\x03\x44\x00\x45\x00\x56\x01\x46\x00\x47\x00\x48\x00\x88\x00\x89\x00\x93\x03\x91\x03\x8b\x00\x8c\x00\x8b\x03\x49\x00\x4a\x00\x4b\x00\x85\x03\x84\x03\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x83\x03\x81\x03\x82\x03\x4c\x00\x80\x03\x11\x00\x7b\x03\x7a\x00\x7b\x00\x7f\x03\x91\x02\xa0\x00\x7e\x03\x18\xfd\x8c\x00\x6a\x01\x6c\x03\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\xae\x02\x13\x00\x97\x03\x97\x00\xef\x00\x98\x03\x69\x03\x8c\x00\xcc\x00\x14\x00\xaf\x02\xd0\x00\x61\x03\x78\x03\x77\x03\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\x15\x00\x5c\x03\x5a\x03\x4e\x03\xcc\x00\x58\x03\x17\x00\x18\x00\x19\x00\x87\x00\x3c\x03\x34\x01\x31\x03\x37\x03\x30\x03\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xea\x00\x2d\x03\x24\x00\x9c\x00\x9d\x00\xcd\x00\x29\x03\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0d\x01\x9e\x00\x70\x00\xd8\x03\xfd\x03\x71\x00\x72\x00\x46\x04\x9c\x00\x9d\x00\xcd\x00\x3c\x04\x43\x04\x41\x04\x36\x04\x33\x04\x34\x04\x32\x04\x9e\x00\x70\x00\x21\x01\x30\x04\x71\x00\x72\x00\x22\x01\x0f\xfd\x71\x00\x23\x01\x2d\x04\x0e\xfd\x9a\x01\x0f\x00\x10\x00\x10\xfd\x23\x04\x1d\x04\x67\x03\x1a\x04\x11\x00\x17\x04\x7a\x00\x7b\x00\x18\x04\x15\x04\xa0\x00\x11\x04\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x24\x01\x0d\x04\xcb\x02\x25\x01\x6b\x05\x11\x00\x68\x00\x7a\x00\x7b\x00\x11\x00\x02\x04\xa0\x00\x26\x01\x20\x02\x21\x02\x0b\x04\xec\x03\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xec\x00\xed\x00\xad\x02\x05\x04\x11\x03\x87\x01\x43\x00\xef\x00\xfd\x03\x45\x00\x8c\x00\x46\x00\xf3\x03\xaf\x02\xd0\x00\xed\x03\x7f\x00\x55\x01\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xb0\x02\xce\x00\x3e\x02\xe2\x03\x8c\x00\x80\x00\x81\x00\xcf\x00\xd0\x00\xe4\x03\xe3\x03\x82\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\xd8\x03\x36\x00\x37\x00\x38\x00\x08\x01\xa3\x04\x9b\x04\x07\x01\xee\x02\x95\x04\x3d\x01\x56\x01\x3d\x00\x3e\x00\x3f\x00\x88\x00\x89\x00\x08\x01\x92\x04\x8b\x00\x8c\x00\x6e\x02\x90\x04\x9c\x00\x9d\x00\x67\x03\xc0\x01\xd8\x01\x4c\x04\xd9\x01\x8b\x04\x8b\x03\xda\x01\x9e\x00\x70\x00\x84\x04\x83\x04\x71\x00\x72\x00\x17\x04\x9c\x00\x9d\x00\x10\x03\x87\x01\x43\x00\x4c\x01\x82\x04\x45\x00\x15\x04\x46\x00\x9e\x00\x70\x00\x40\x00\x07\x01\x71\x00\x72\x00\xdd\x01\x15\x04\x62\x04\x25\x01\x59\x04\xd1\x00\x9f\x00\x0f\x00\xd2\x00\x11\x00\x5e\x04\x7a\x00\x7b\x00\x55\x04\x11\x00\x54\x04\x7a\x00\x7b\x00\x53\x04\x52\x04\xa0\x00\x50\x04\xd1\x00\x9f\x00\x0f\x00\xd2\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x4f\x04\x11\x00\x4e\x04\x7a\x00\x7b\x00\x4d\x04\x4c\x04\xa0\x00\x36\x00\x37\x00\x38\x00\xeb\x04\xd3\x02\x4d\x01\xe8\x04\x4e\x01\xe4\x04\x3c\x00\xdd\x04\x3d\x00\x3e\x00\x3f\x00\x79\x03\x87\x01\x43\x00\xd8\x04\xc5\x04\x45\x00\x15\x04\x46\x00\xbe\x04\x70\x03\xbd\x04\x1e\x05\xb3\x04\x23\x05\x17\x05\x1d\x05\x31\x05\x42\x00\x43\x00\x08\x01\x44\x00\x45\x00\x25\x05\x46\x00\x47\x00\x48\x00\x10\x05\x0f\x05\x0d\x05\x0e\x05\x67\x05\x59\x01\x65\x05\x49\x00\x4a\x00\x4b\x00\x68\x05\x40\x00\x5f\x05\x36\x00\x37\x00\x38\x00\x01\x05\x5c\x03\x4d\x01\x4c\x00\x4e\x01\x4f\x05\x3c\x00\x50\x05\x3d\x00\x3e\x00\x3f\x00\x4d\x05\x4c\x05\x08\x01\x08\x01\x35\x05\x36\x00\x37\x00\x38\x00\x3e\x05\x3d\x05\x4d\x01\x82\x05\x4e\x01\x47\x05\x3c\x00\x7f\x05\x3d\x00\x3e\x00\x3f\x00\x72\x05\x3c\x05\x3b\x05\x83\x05\x70\x01\x71\x01\x72\x01\x73\x01\x74\x01\xd8\x03\x75\x01\x78\x05\x66\xfe\x07\x01\x22\x01\x17\x04\x71\x00\x23\x01\x40\x00\x36\x00\x37\x00\x38\x00\x5d\x05\x15\x04\x4d\x01\x6b\x05\x4e\x01\x95\x05\x3c\x00\x17\x04\x3d\x00\x3e\x00\x3f\x00\x15\x04\xd1\x03\x8f\x05\x08\x01\x40\x00\x42\x00\x43\x00\x24\x01\x44\x00\x45\x00\x25\x01\x46\x00\x47\x00\x48\x00\x8e\x05\x9a\x05\x11\x00\x9b\x05\x15\x04\x26\x01\x03\x02\x49\x00\x4a\x00\x4b\x00\x9d\x05\x86\x01\x87\x01\x43\x00\x0b\x01\xd2\x01\x45\x00\x84\x01\x46\x00\x4c\x00\x90\x01\x56\x01\xc1\x01\x40\x00\x36\x00\x37\x00\x38\x00\xb9\x01\x88\x01\x4d\x01\x4b\x00\x4e\x01\x41\x01\x3c\x00\x46\x01\x3d\x00\x3e\x00\x3f\x00\x39\x01\xb5\x01\x4c\x00\x19\x01\x1b\x03\x17\x03\x42\x00\x43\x00\x0a\x03\x44\x00\x45\x00\x1a\x03\x46\x00\x47\x00\x48\x00\x19\x03\x0d\x03\x04\x03\xf6\x02\xf0\x02\xe0\x02\xc4\x02\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x7f\x00\x44\x00\x45\x00\xe7\x01\x46\x00\x47\x00\x48\x00\x4c\x00\xd2\x02\x8e\x02\x40\x00\x78\x02\x80\x00\x81\x00\x49\x00\x4a\x00\x4b\x00\x6c\x02\x82\x00\xd5\x03\x43\x04\x87\x01\x43\x00\xd4\x03\x20\x03\x45\x00\x4c\x00\x46\x00\x17\x02\xd3\x03\x12\x02\x42\x00\x43\x00\x69\x03\x44\x00\x45\x00\x56\x01\x46\x00\x47\x00\x48\x00\x88\x00\x89\x00\x0f\x02\xbe\x03\x8b\x00\x8c\x00\x6a\x02\x49\x00\x4a\x00\x4b\x00\x5f\x03\x36\x00\x37\x00\x38\x00\x42\x02\x5a\x03\x3a\x00\x7f\x00\x3b\x00\x4c\x00\x3c\x00\x58\x03\x3d\x00\x3e\x00\x3f\x00\x69\x03\x41\x04\x87\x01\x43\x00\x80\x00\x81\x00\x45\x00\x56\x03\x46\x00\x4e\x03\x82\x00\x3a\x03\x37\x03\xb7\x03\x95\x03\x8c\x03\x35\x03\x8b\x03\x42\x00\x43\x00\x42\x03\x44\x00\x45\x00\x27\x03\x46\x00\x47\x00\x48\x00\x26\x03\xa4\x02\x23\x03\x4a\x04\x49\x04\x88\x00\x89\x00\x49\x00\x4a\x00\x4b\x00\x40\x00\x48\x04\x47\x04\x46\x04\x34\x04\x44\x04\x2b\x04\x28\x04\x25\x04\x4c\x00\x36\x00\x37\x00\x38\x00\xe4\x01\x1d\x04\x3a\x00\x1b\x04\x3b\x00\x15\x04\x3c\x00\xfb\x03\x3d\x00\x3e\x00\x3f\x00\xf3\x03\xd9\x03\xd8\x03\xe5\x01\xe6\x01\xd6\x03\x90\x04\x7b\x03\x72\x01\x73\x01\x74\x01\x8e\x04\x75\x01\x6a\x02\x80\x04\x7a\x04\x22\x01\x7b\x04\x71\x00\x23\x01\x6b\x04\x60\x04\x50\x04\xee\x04\xeb\x04\xe9\x04\xe0\x04\xde\x04\xdd\x04\xdb\x04\x41\x00\xd8\x04\xd6\x04\xc3\x04\xb3\x04\xbb\x04\xa3\x04\x40\x00\x23\x05\x2e\x05\x2f\x05\x20\x05\x24\x01\x1f\x05\x10\x05\x25\x01\x08\x05\x15\x05\xf8\x04\x42\x00\x43\x00\x11\x00\x44\x00\x45\x00\x26\x01\x46\x00\x47\x00\x48\x00\x00\x05\x5a\x05\xf1\x04\x36\x00\x37\x00\x38\x00\x68\x05\x49\x00\x4a\x00\x4b\x00\x3c\x01\x45\x05\x3d\x01\x62\x05\x3d\x00\x3e\x00\x3f\x00\x43\x02\x78\x00\x4c\x00\x79\x00\x57\x05\x61\x05\xd4\x01\x7d\x00\x69\x03\x44\x05\x79\x05\xd5\x01\x78\x05\x89\x05\x6f\x05\x93\x05\x41\x00\x36\x00\x37\x00\x38\x00\xe9\x01\x87\x05\x3a\x00\x97\x05\x3b\x00\x98\x05\x3c\x00\x96\x05\x3d\x00\x3e\x00\x3f\x00\x9b\x05\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x40\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\xbf\x02\x72\x01\x73\x01\x74\x01\x00\x00\x75\x01\x00\x00\x00\x00\x4c\x00\x22\x01\x00\x00\x71\x00\x23\x01\x40\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x00\x00\x36\x00\x37\x00\x38\x00\xe9\x01\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x24\x01\x00\x00\x00\x00\x25\x01\x00\x00\x00\x00\x00\x00\x43\x02\x78\x00\x11\x00\x79\x00\x00\x00\x26\x01\x00\x00\xc0\x02\x00\x00\x00\x00\x00\x00\xd5\x01\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x40\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x33\x03\x2d\x01\x00\x00\x00\x00\x00\x00\x22\x01\x4c\x00\x71\x00\x23\x01\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\xea\x01\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x24\x01\x00\x00\x00\x00\x25\x01\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x26\x01\xd4\x02\xa4\x02\xeb\x01\x41\x00\x36\x00\x37\x00\x38\x00\x5b\x02\xa5\x02\xd5\x02\x00\x00\x3b\x00\xa7\x02\xd6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\xea\x01\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x70\x05\x4a\x00\x4b\x00\x00\x00\xd7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x82\x00\x00\x00\x40\x00\xb7\x02\x00\x00\x00\x00\xeb\x01\x36\x00\x37\x00\x38\x00\x5b\x02\x6c\x01\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x6d\x01\x3d\x00\x3e\x00\x3f\x00\xe9\x02\x88\x00\x89\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x02\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x5b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\xb8\x02\x00\x00\x00\x00\x00\x00\x7f\x00\xcc\x01\xd7\x02\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\xcd\x01\xce\x01\xcf\x01\xd0\x01\x82\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x7f\x00\x55\x01\xb4\xfe\x40\x00\x00\x00\xb4\xfe\x56\x01\x49\x00\x4a\x00\x4b\x00\x88\x00\x89\x00\x80\x00\x81\x00\x8b\x00\x8c\x00\xb7\x02\x00\x00\x82\x00\x4c\x00\x36\x00\x37\x00\x38\x00\x5b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x24\x04\x00\x00\x56\x01\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\xed\x01\x00\x00\x9d\x02\xef\x01\x08\x04\x57\x00\x4c\x00\x0b\x04\x36\x00\x37\x00\x38\x00\x5b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x9e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x6d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x00\x00\x00\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x96\x01\x70\x00\x00\x00\x40\x00\x71\x00\x72\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x08\x04\x00\x00\x00\x00\x09\x04\x36\x00\x37\x00\x38\x00\x5b\x02\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x97\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x08\x04\x00\x00\x00\x00\xc1\x04\x36\x00\x37\x00\x38\x00\x5b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x41\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x5a\x02\x00\x00\x40\x00\x00\x00\x36\x00\x37\x00\x38\x00\x5b\x02\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x06\x05\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x56\x01\x49\x00\x4a\x00\x4b\x00\x88\x00\x89\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x51\x05\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x5b\x02\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x41\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\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\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x41\x03\x00\x00\x4c\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\x00\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xd8\x01\x00\x00\xd9\x01\x00\x00\x00\x00\xda\x01\x00\x00\x00\x00\xdb\x01\x00\x00\x03\x04\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa5\x02\xa6\x02\x00\x00\xdc\x01\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xdd\x01\x00\x00\x41\x00\x25\x01\x00\x00\x00\x00\x40\x00\xde\x01\x78\x00\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x5c\x04\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa5\x02\xa6\x02\x4c\x00\x00\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\xa9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\xe4\x04\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa5\x02\xa6\x02\x4c\x00\x00\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x8c\x00\xe2\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x59\x05\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xa5\x02\xa6\x02\x4c\x00\x50\x01\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x01\x00\x00\x52\x01\x53\x01\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x75\x00\x00\x00\x76\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x42\x00\x43\x00\xa0\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x49\x00\x4a\x00\x4b\x00\x50\x01\xec\x02\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x51\x01\x00\x00\x52\x01\x53\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x76\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x19\x02\xa2\x00\x13\x00\xa3\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x02\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\xb1\x03\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\xfa\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\x15\x00\x00\x00\xfc\x00\x00\x00\x16\x00\xfd\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\xff\x00\xab\x00\xdc\x00\xad\x00\x00\x01\x01\x01\x00\x00\x00\x00\x02\x01\x03\x01\x04\x01\x05\x01\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x71\x04\x72\x04\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x73\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x68\x04\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\x15\x00\x00\x00\x69\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x71\x04\x72\x04\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x73\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x68\x04\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\x15\x00\x00\x00\x69\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfe\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x07\x01\x08\x01\x09\x01\x0a\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x7f\x00\x00\x00\x56\x04\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\xab\x00\xac\x00\xad\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x56\x01\xae\x00\x00\x00\x6a\x01\x88\x00\x89\x00\x00\x00\xaf\x00\x8b\x00\x8c\x00\x6b\x01\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x6c\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x6d\x01\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x6a\x01\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\xa1\x01\xb6\x00\x00\x00\x00\x00\x6d\x01\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x6a\x01\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x6b\x01\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x6c\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x6d\x01\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x51\x02\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x36\x02\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x54\x02\xb6\x00\x00\x00\x00\x00\x36\x02\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\xd4\x00\xd5\x00\xd6\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\xd8\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x50\x01\xab\x00\xdc\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\xcf\x02\x00\x00\x52\x01\x53\x01\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x75\x00\x00\x00\x76\x00\x77\x00\x78\x00\xaf\x00\x79\x00\x00\x00\xb0\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xdf\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xa9\x01\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\xcb\x02\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x36\x02\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x6e\x01\xb7\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x03\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\xb1\x03\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\xa9\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x01\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x01\x00\x00\x52\x01\x53\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x75\x00\xc0\x01\x76\x00\x77\x00\x78\x00\xaf\x00\x79\x00\x00\x00\xb0\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x01\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\xa9\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\xa4\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x05\x12\x05\x00\x00\x3d\x00\x3e\x00\x3f\x00\xae\x00\x72\x05\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xe6\xfd\xe6\xfd\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\xe6\xfd\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xfd\x00\x00\x00\x00\x00\x00\xe6\xfd\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\x00\x00\x00\x00\xe6\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\x00\x00\x4c\x00\xe6\xfd\x00\x00\x00\x00\x00\x00\xe6\xfd\x00\x00\x00\x00\xe6\xfd\xe6\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\x00\x00\x00\x00\x00\x00\xe6\xfd\x00\x00\xe6\xfd\x00\x00\xe6\xfd\x00\x00\xe6\xfd\x00\x00\xe6\xfd\x00\x00\x00\x00\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\x00\x00\xe6\xfd\x00\x00\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xe6\xfd\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\xb1\x03\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\xa9\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\xa4\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\xf8\x03\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\xa2\x00\x13\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x14\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa8\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x02\x00\x00\x3d\x01\xae\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x40\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x01\x00\x00\x00\x00\x00\x00\x4c\x00\xaf\x00\x36\x00\x37\x00\x38\x00\xb0\x01\x4c\x03\xa6\x02\x00\x00\x00\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x40\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\xc8\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x4c\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x36\x00\x37\x00\x38\x00\x24\x02\xff\x03\xd5\x02\x00\x00\x3b\x00\xa7\x02\xd6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x40\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\xd7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\xc8\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x4c\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x02\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\xb0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x36\x00\x37\x00\x38\x00\x23\x02\xfe\x03\xd5\x02\x00\x00\x3b\x00\xa7\x02\xd6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x40\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\xd7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x61\x03\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\xb2\x00\x4c\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x9a\x03\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x40\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x4c\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\xa2\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x4b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xe3\x02\x4d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2b\x00\x87\x00\x40\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x68\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\x00\x00\x4e\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x41\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\xed\x01\x00\x00\xee\x01\xef\x01\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\xf0\x01\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x53\x00\x54\x00\x00\x00\x18\x04\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\xe9\x01\x40\x00\x00\x00\x00\x00\x6d\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x02\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x46\x02\x47\x02\x00\x00\x00\x00\x00\x00\x00\x00\x48\x02\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x6c\x01\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x49\x02\x4a\x02\x00\x00\x65\x00\x66\x00\x4b\x02\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x04\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\xf4\x01\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\xf2\x01\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x01\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x40\x01\x41\x01\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\x06\x05\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xd9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x53\x00\x54\x00\x04\x05\x00\x00\x3d\x01\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xab\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xab\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xd9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xab\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xab\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xd9\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xab\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x04\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\xd5\x04\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\xab\x02\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x56\x05\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x4f\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x15\x05\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x04\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xff\x03\xa6\x02\x00\x00\x7f\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x56\x00\x00\x00\x9a\xfe\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x02\x06\x02\x61\x00\x62\x00\x00\x00\x89\x00\x00\x00\x65\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x02\x06\x02\x61\x00\x62\x00\x00\x00\x89\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x4e\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x15\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x54\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x4b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x4c\x02\x4d\x02\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x02\x61\x00\x62\x00\x40\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x6a\x00\x36\x00\x37\x00\x38\x00\xcf\x03\x75\x04\xd5\x02\x00\x00\x3b\x00\xa7\x02\xd6\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x4b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x41\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xcc\x03\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x36\x00\x37\x00\x38\x00\xca\x03\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\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\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x4b\x02\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x41\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xc9\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x36\x00\x37\x00\x38\x00\xc7\x03\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x4b\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xc6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xca\x03\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x41\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x04\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\xca\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x04\x00\x00\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xca\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x0f\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x36\x00\x37\x00\x38\x00\x4b\x02\x00\x00\x3a\x00\x40\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xe4\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\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xca\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x42\x00\x43\x00\x40\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\xdd\x03\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4c\x00\x36\x00\x37\x00\x38\x00\xca\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x56\x05\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x40\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\x2d\x04\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x3a\x00\x41\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\xf2\x01\x00\x00\x3a\x00\x40\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xf0\x01\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x42\x00\x43\x00\x40\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x05\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\x93\x01\x00\x00\x3a\x00\x41\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x36\x00\x37\x00\x38\x00\x24\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4c\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x36\x00\x37\x00\x38\x00\x23\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\xcf\x03\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x40\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x2d\x04\x00\x00\x3a\x00\x41\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x36\x00\x37\x00\x38\x00\xde\x03\x4c\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x40\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\xfe\x03\xa6\x02\x00\x00\x4c\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x36\x00\x37\x00\x38\x00\x00\x00\x75\x04\xa6\x02\x00\x00\x41\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xab\x03\xac\x03\xad\x03\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xae\x03\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x40\x00\x71\x00\x72\x00\x4c\x00\x36\x00\x37\x00\x38\x00\x00\x00\x76\x04\xa6\x02\x00\x00\x00\x00\xa7\x02\xa8\x02\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xaf\x03\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\xa9\x02\x40\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x36\x00\x37\x00\x38\x00\xf6\x04\x00\x00\x3a\x00\xa9\x02\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x13\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x40\x00\x00\x00\x4c\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x48\x03\x49\x03\x4a\x03\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x41\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x43\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x00\x00\x00\x00\x2c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x4b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x2c\x02\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x4b\x03\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x02\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x4b\x03\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x21\x02\x8d\x05\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x02\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\xb9\x04\x29\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x21\x02\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x02\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x21\x02\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x22\x02\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x02\x21\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x13\x00\x00\x00\x84\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x86\x00\x00\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x01\xc9\x02\x13\x00\x00\x00\xe1\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\xe2\x01\x00\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x00\x00\x8a\x00\x00\x00\x8c\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x8c\x00\x13\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x14\x00\xac\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x04\x00\x00\x00\x00\x15\x00\x00\x00\xaf\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\xad\x01\x24\x00\x00\x00\x00\x00\xb0\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x13\x00\x7a\x00\x7b\x00\x00\x00\xb1\x04\xa0\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\xb2\x04\x00\x00\x00\x00\x2b\x00\x62\x00\x00\x00\xae\x04\x2c\x00\x65\x00\x15\x00\x00\x00\xaf\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\xb0\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x62\x00\x00\x00\x00\x00\x2c\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x13\x00\x00\x00\x00\x00\x99\x01\x00\x00\x85\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x15\x00\x00\x00\xaf\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x3a\x05\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x62\x00\x00\x00\x00\x00\x2c\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\xe0\x01\x00\x00\x00\x00\x00\x00\xe1\x01\x14\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x15\x00\x00\x00\x8a\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x8a\x01\x00\x00\x8b\x01\x00\x00\x8c\x01\x14\x00\x8d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x00\x00\x15\x00\x00\x00\x65\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x20\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x15\x00\x00\x00\x21\x01\x65\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x63\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x00\x00\x00\x00\x16\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x2b\x00\x00\x00\x00\x00\x16\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x13\x00\x00\x00\x00\x00\x77\x01\x6c\x01\x85\x00\x00\x00\x00\x00\x14\x00\x00\x00\x6d\x01\x00\x00\x00\x00\x2b\x00\x87\x00\x88\x00\x89\x00\x28\x01\x00\x00\x00\x00\x15\x00\x00\x00\x29\x01\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x14\x00\x00\x00\x00\x00\x77\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x87\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x39\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x14\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x87\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x77\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x14\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2b\x00\x87\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x13\x00\x8c\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x14\x00\x00\x00\x00\x00\xac\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x7b\x02\x7c\x02\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x2b\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\xff\x00\x00\x00\x00\x00\x00\x0a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\xfd\x02\x14\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x15\x00\x00\x00\xc7\x02\x00\x00\x16\x00\x2b\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2b\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x3a\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x2b\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x00\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2b\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x13\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x3a\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x13\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x14\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xff\x01\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x15\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x22\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x17\x00\x18\x00\x19\x00\x50\x00\x51\x00\x52\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xff\x01\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x8c\x00\x5a\x01\x5b\x01\x61\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x5d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x63\x01\xa1\x01\x65\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x66\x01\x7d\x00\xa0\x00\x00\x00\x00\x00\x67\x01\x00\x00\x68\x01\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x5d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x63\x01\x64\x01\x65\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x66\x01\x7d\x00\xa0\x00\x00\x00\x00\x00\x67\x01\x00\x00\x68\x01\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x01\x9c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x00\x00\x00\x00\x9f\x01\x00\x00\x68\x01\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x01\x00\x00\x00\x00\x00\x00\xa6\x01\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x02\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x02\x00\x00\x00\x00\x9a\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\xa5\x03\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x9c\x03\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x5a\x01\x5b\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x5e\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\x5f\x01\x60\x01\x00\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x62\x01\x9d\x01\x00\x00\x9e\x01\x11\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xa0\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x03\x9f\x03\xa0\x03\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\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x9e\x03\x9f\x03\xa0\x03\xa1\x03\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x87\x04\xa0\x03\xa1\x03\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x9a\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x72\x02\x00\x00\x71\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x70\x02\x00\x00\x71\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x67\x02\x68\x02\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xb1\x03\xac\x03\xad\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x62\x03\x68\x02\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xed\x03\xac\x03\xad\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x8c\x00\xbb\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\xbc\x01\xbd\x01\xbe\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x03\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x85\x04\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x8c\x04\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\xae\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x3d\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xdf\x00\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x3c\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xd7\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc9\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc8\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc2\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x95\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8f\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8e\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x01\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x63\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x59\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x58\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x57\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x56\x02\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xb9\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xb8\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xb4\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xa7\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xa4\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x63\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x2b\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x04\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xf6\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xf4\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xe9\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xe7\x03\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8d\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x8b\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x84\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x74\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xe8\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xc0\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xbf\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\xbe\x04\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x1e\x05\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x47\x05\x8e\x00\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x94\x01\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\xcc\x02\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\x3a\x04\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x8c\x00\x00\x00\xd5\x04\x00\x00\x8f\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x8c\x00\x00\x00\x71\x00\x72\x00\x8f\x00\x5c\x02\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x9e\x00\x70\x00\xd9\x02\x00\x00\x71\x00\x72\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x01\x95\x00\x96\x00\x97\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x7b\x02\xaa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\xaa\x01\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\xc6\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\xb4\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\xab\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x59\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x1b\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x03\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x0e\x03\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\xc6\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x99\x01\x97\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x64\x02\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x31\x03\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x9a\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x70\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 (13, 818) [+ (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),+ (630 , happyReduce_630),+ (631 , happyReduce_631),+ (632 , happyReduce_632),+ (633 , happyReduce_633),+ (634 , happyReduce_634),+ (635 , happyReduce_635),+ (636 , happyReduce_636),+ (637 , happyReduce_637),+ (638 , happyReduce_638),+ (639 , happyReduce_639),+ (640 , happyReduce_640),+ (641 , happyReduce_641),+ (642 , happyReduce_642),+ (643 , happyReduce_643),+ (644 , happyReduce_644),+ (645 , happyReduce_645),+ (646 , happyReduce_646),+ (647 , happyReduce_647),+ (648 , happyReduce_648),+ (649 , happyReduce_649),+ (650 , happyReduce_650),+ (651 , happyReduce_651),+ (652 , happyReduce_652),+ (653 , happyReduce_653),+ (654 , happyReduce_654),+ (655 , happyReduce_655),+ (656 , happyReduce_656),+ (657 , happyReduce_657),+ (658 , happyReduce_658),+ (659 , happyReduce_659),+ (660 , happyReduce_660),+ (661 , happyReduce_661),+ (662 , happyReduce_662),+ (663 , happyReduce_663),+ (664 , happyReduce_664),+ (665 , happyReduce_665),+ (666 , happyReduce_666),+ (667 , happyReduce_667),+ (668 , happyReduce_668),+ (669 , happyReduce_669),+ (670 , happyReduce_670),+ (671 , happyReduce_671),+ (672 , happyReduce_672),+ (673 , happyReduce_673),+ (674 , happyReduce_674),+ (675 , happyReduce_675),+ (676 , happyReduce_676),+ (677 , happyReduce_677),+ (678 , happyReduce_678),+ (679 , happyReduce_679),+ (680 , happyReduce_680),+ (681 , happyReduce_681),+ (682 , happyReduce_682),+ (683 , happyReduce_683),+ (684 , happyReduce_684),+ (685 , happyReduce_685),+ (686 , happyReduce_686),+ (687 , happyReduce_687),+ (688 , happyReduce_688),+ (689 , happyReduce_689),+ (690 , happyReduce_690),+ (691 , happyReduce_691),+ (692 , happyReduce_692),+ (693 , happyReduce_693),+ (694 , happyReduce_694),+ (695 , happyReduce_695),+ (696 , happyReduce_696),+ (697 , happyReduce_697),+ (698 , happyReduce_698),+ (699 , happyReduce_699),+ (700 , happyReduce_700),+ (701 , happyReduce_701),+ (702 , happyReduce_702),+ (703 , happyReduce_703),+ (704 , happyReduce_704),+ (705 , happyReduce_705),+ (706 , happyReduce_706),+ (707 , happyReduce_707),+ (708 , happyReduce_708),+ (709 , happyReduce_709),+ (710 , happyReduce_710),+ (711 , happyReduce_711),+ (712 , happyReduce_712),+ (713 , happyReduce_713),+ (714 , happyReduce_714),+ (715 , happyReduce_715),+ (716 , happyReduce_716),+ (717 , happyReduce_717),+ (718 , happyReduce_718),+ (719 , happyReduce_719),+ (720 , happyReduce_720),+ (721 , happyReduce_721),+ (722 , happyReduce_722),+ (723 , happyReduce_723),+ (724 , happyReduce_724),+ (725 , happyReduce_725),+ (726 , happyReduce_726),+ (727 , happyReduce_727),+ (728 , happyReduce_728),+ (729 , happyReduce_729),+ (730 , happyReduce_730),+ (731 , happyReduce_731),+ (732 , happyReduce_732),+ (733 , happyReduce_733),+ (734 , happyReduce_734),+ (735 , happyReduce_735),+ (736 , happyReduce_736),+ (737 , happyReduce_737),+ (738 , happyReduce_738),+ (739 , happyReduce_739),+ (740 , happyReduce_740),+ (741 , happyReduce_741),+ (742 , happyReduce_742),+ (743 , happyReduce_743),+ (744 , happyReduce_744),+ (745 , happyReduce_745),+ (746 , happyReduce_746),+ (747 , happyReduce_747),+ (748 , happyReduce_748),+ (749 , happyReduce_749),+ (750 , happyReduce_750),+ (751 , happyReduce_751),+ (752 , happyReduce_752),+ (753 , happyReduce_753),+ (754 , happyReduce_754),+ (755 , happyReduce_755),+ (756 , happyReduce_756),+ (757 , happyReduce_757),+ (758 , happyReduce_758),+ (759 , happyReduce_759),+ (760 , happyReduce_760),+ (761 , happyReduce_761),+ (762 , happyReduce_762),+ (763 , happyReduce_763),+ (764 , happyReduce_764),+ (765 , happyReduce_765),+ (766 , happyReduce_766),+ (767 , happyReduce_767),+ (768 , happyReduce_768),+ (769 , happyReduce_769),+ (770 , happyReduce_770),+ (771 , happyReduce_771),+ (772 , happyReduce_772),+ (773 , happyReduce_773),+ (774 , happyReduce_774),+ (775 , happyReduce_775),+ (776 , happyReduce_776),+ (777 , happyReduce_777),+ (778 , happyReduce_778),+ (779 , happyReduce_779),+ (780 , happyReduce_780),+ (781 , happyReduce_781),+ (782 , happyReduce_782),+ (783 , happyReduce_783),+ (784 , happyReduce_784),+ (785 , happyReduce_785),+ (786 , happyReduce_786),+ (787 , happyReduce_787),+ (788 , happyReduce_788),+ (789 , happyReduce_789),+ (790 , happyReduce_790),+ (791 , happyReduce_791),+ (792 , happyReduce_792),+ (793 , happyReduce_793),+ (794 , happyReduce_794),+ (795 , happyReduce_795),+ (796 , happyReduce_796),+ (797 , happyReduce_797),+ (798 , happyReduce_798),+ (799 , happyReduce_799),+ (800 , happyReduce_800),+ (801 , happyReduce_801),+ (802 , happyReduce_802),+ (803 , happyReduce_803),+ (804 , happyReduce_804),+ (805 , happyReduce_805),+ (806 , happyReduce_806),+ (807 , happyReduce_807),+ (808 , happyReduce_808),+ (809 , happyReduce_809),+ (810 , happyReduce_810),+ (811 , happyReduce_811),+ (812 , happyReduce_812),+ (813 , happyReduce_813),+ (814 , happyReduce_814),+ (815 , happyReduce_815),+ (816 , happyReduce_816),+ (817 , happyReduce_817),+ (818 , happyReduce_818)+ ]++happy_n_terms = 156 :: Int+happy_n_nonterms = 303 :: Int++happyReduce_13 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_13 = happySpecReduce_1 0# happyReduction_13+happyReduction_13 happy_x_1+ = case happyOut292 happy_x_1 of { happy_var_1 -> + happyIn16+ (happy_var_1+ )}++happyReduce_14 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_14 = happySpecReduce_1 0# happyReduction_14+happyReduction_14 happy_x_1+ = case happyOut263 happy_x_1 of { happy_var_1 -> + happyIn16+ (happy_var_1+ )}++happyReduce_15 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_15 = happySpecReduce_1 0# happyReduction_15+happyReduction_15 happy_x_1+ = case happyOut286 happy_x_1 of { happy_var_1 -> + happyIn16+ (happy_var_1+ )}++happyReduce_16 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_16 = happySpecReduce_1 0# happyReduction_16+happyReduction_16 happy_x_1+ = case happyOut270 happy_x_1 of { happy_var_1 -> + happyIn16+ (happy_var_1+ )}++happyReduce_17 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_17 = happyMonadReduce 3# 0# happyReduction_17+happyReduction_17 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)+ [mj AnnOpenP happy_var_1,mu AnnRarrow happy_var_2,mj AnnCloseP happy_var_3])}}})+ ) (\r -> happyReturn (happyIn16 r))++happyReduce_18 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_18 = happySpecReduce_3 1# happyReduction_18+happyReduction_18 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut18 happy_x_2 of { happy_var_2 -> + happyIn17+ (fromOL happy_var_2+ )}++happyReduce_19 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_19 = happySpecReduce_3 1# happyReduction_19+happyReduction_19 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut18 happy_x_2 of { happy_var_2 -> + happyIn17+ (fromOL happy_var_2+ )}++happyReduce_20 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_20 = happySpecReduce_3 2# happyReduction_20+happyReduction_20 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOut19 happy_x_3 of { happy_var_3 -> + happyIn18+ (happy_var_1 `appOL` unitOL happy_var_3+ )}}++happyReduce_21 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_21 = happySpecReduce_2 2# happyReduction_21+happyReduction_21 happy_x_2+ happy_x_1+ = case happyOut18 happy_x_1 of { happy_var_1 -> + happyIn18+ (happy_var_1+ )}++happyReduce_22 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_22 = happySpecReduce_1 2# happyReduction_22+happyReduction_22 happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn18+ (unitOL happy_var_1+ )}++happyReduce_23 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_23 = happyReduce 4# 3# happyReduction_23+happyReduction_23 (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 happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut30 happy_x_4 of { happy_var_4 -> + happyIn19+ (sL1 happy_var_1 $ HsUnit { hsunitName = happy_var_2+ , hsunitBody = fromOL happy_var_4 }+ ) `HappyStk` happyRest}}}++happyReduce_24 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_24 = happySpecReduce_1 4# happyReduction_24+happyReduction_24 happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn20+ (sL1 happy_var_1 $ HsUnitId happy_var_1 []+ )}++happyReduce_25 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_25 = happyReduce 4# 4# happyReduction_25+happyReduction_25 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn20+ (sLL happy_var_1 happy_var_4 $ HsUnitId happy_var_1 (fromOL happy_var_3)+ ) `HappyStk` happyRest}}}++happyReduce_26 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_26 = happySpecReduce_3 5# happyReduction_26+happyReduction_26 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut21 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn21+ (happy_var_1 `appOL` unitOL happy_var_3+ )}}++happyReduce_27 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_27 = happySpecReduce_2 5# happyReduction_27+happyReduction_27 happy_x_2+ happy_x_1+ = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn21+ (happy_var_1+ )}++happyReduce_28 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_28 = happySpecReduce_1 5# happyReduction_28+happyReduction_28 happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn21+ (unitOL happy_var_1+ )}++happyReduce_29 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_29 = happySpecReduce_3 6# happyReduction_29+happyReduction_29 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut308 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn22+ (sLL happy_var_1 happy_var_3 $ (happy_var_1, happy_var_3)+ )}}++happyReduce_30 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_30 = happyReduce 4# 6# happyReduction_30+happyReduction_30 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut308 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn22+ (sLL happy_var_1 happy_var_4 $ (happy_var_1, sLL happy_var_2 happy_var_4 $ HsModuleVar happy_var_3)+ ) `HappyStk` happyRest}}}}++happyReduce_31 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_31 = happySpecReduce_3 7# happyReduction_31+happyReduction_31 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut308 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn23+ (sLL happy_var_1 happy_var_3 $ HsModuleVar happy_var_2+ )}}}++happyReduce_32 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_32 = happySpecReduce_3 7# happyReduction_32+happyReduction_32 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + happyIn23+ (sLL happy_var_1 happy_var_3 $ HsModuleId happy_var_1 happy_var_3+ )}}++happyReduce_33 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_33 = happySpecReduce_1 8# happyReduction_33+happyReduction_33 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn24+ (sL1 happy_var_1 $ PackageName (getSTRING happy_var_1)+ )}++happyReduce_34 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_34 = happySpecReduce_1 8# happyReduction_34+happyReduction_34 happy_x_1+ = case happyOut26 happy_x_1 of { happy_var_1 -> + happyIn24+ (sL1 happy_var_1 $ PackageName (unLoc happy_var_1)+ )}++happyReduce_35 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_35 = happySpecReduce_1 9# happyReduction_35+happyReduction_35 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn25+ (sL1 happy_var_1 $ getVARID happy_var_1+ )}++happyReduce_36 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_36 = happySpecReduce_1 9# happyReduction_36+happyReduction_36 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn25+ (sL1 happy_var_1 $ getCONID happy_var_1+ )}++happyReduce_37 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_37 = happySpecReduce_1 9# happyReduction_37+happyReduction_37 happy_x_1+ = case happyOut300 happy_x_1 of { happy_var_1 -> + happyIn25+ (happy_var_1+ )}++happyReduce_38 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_38 = happySpecReduce_1 10# happyReduction_38+happyReduction_38 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn26+ (happy_var_1+ )}++happyReduce_39 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_39 = happySpecReduce_3 10# happyReduction_39+happyReduction_39 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn26+ (sLL happy_var_1 happy_var_3 $ appendFS (unLoc happy_var_1) (consFS '-' (unLoc happy_var_3))+ )}}++happyReduce_40 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_40 = happySpecReduce_0 11# happyReduction_40+happyReduction_40 = happyIn27+ (Nothing+ )++happyReduce_41 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_41 = happySpecReduce_3 11# happyReduction_41+happyReduction_41 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut28 happy_x_2 of { happy_var_2 -> + happyIn27+ (Just (fromOL happy_var_2)+ )}++happyReduce_42 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_42 = happySpecReduce_3 12# happyReduction_42+happyReduction_42 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut28 happy_x_1 of { happy_var_1 -> + case happyOut29 happy_x_3 of { happy_var_3 -> + happyIn28+ (happy_var_1 `appOL` unitOL happy_var_3+ )}}++happyReduce_43 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_43 = happySpecReduce_2 12# happyReduction_43+happyReduction_43 happy_x_2+ happy_x_1+ = case happyOut28 happy_x_1 of { happy_var_1 -> + happyIn28+ (happy_var_1+ )}++happyReduce_44 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_44 = happySpecReduce_1 12# happyReduction_44+happyReduction_44 happy_x_1+ = case happyOut29 happy_x_1 of { happy_var_1 -> + happyIn28+ (unitOL happy_var_1+ )}++happyReduce_45 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_45 = happySpecReduce_3 13# happyReduction_45+happyReduction_45 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut308 happy_x_1 of { happy_var_1 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + happyIn29+ (sLL happy_var_1 happy_var_3 $ Renaming happy_var_1 (Just happy_var_3)+ )}}++happyReduce_46 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_46 = happySpecReduce_1 13# happyReduction_46+happyReduction_46 happy_x_1+ = case happyOut308 happy_x_1 of { happy_var_1 -> + happyIn29+ (sL1 happy_var_1 $ Renaming happy_var_1 Nothing+ )}++happyReduce_47 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_47 = happySpecReduce_3 14# happyReduction_47+happyReduction_47 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut31 happy_x_2 of { happy_var_2 -> + happyIn30+ (happy_var_2+ )}++happyReduce_48 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_48 = happySpecReduce_3 14# happyReduction_48+happyReduction_48 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut31 happy_x_2 of { happy_var_2 -> + happyIn30+ (happy_var_2+ )}++happyReduce_49 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_49 = happySpecReduce_3 15# happyReduction_49+happyReduction_49 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut31 happy_x_1 of { happy_var_1 -> + case happyOut32 happy_x_3 of { happy_var_3 -> + happyIn31+ (happy_var_1 `appOL` unitOL happy_var_3+ )}}++happyReduce_50 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_50 = happySpecReduce_2 15# happyReduction_50+happyReduction_50 happy_x_2+ happy_x_1+ = case happyOut31 happy_x_1 of { happy_var_1 -> + happyIn31+ (happy_var_1+ )}++happyReduce_51 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_51 = happySpecReduce_1 15# happyReduction_51+happyReduction_51 happy_x_1+ = case happyOut32 happy_x_1 of { happy_var_1 -> + happyIn31+ (unitOL happy_var_1+ )}++happyReduce_52 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_52 = happyReduce 7# 16# happyReduction_52+happyReduction_52 (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 happyOut35 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + case happyOut38 happy_x_4 of { happy_var_4 -> + case happyOut48 happy_x_5 of { happy_var_5 -> + case happyOut39 happy_x_7 of { happy_var_7 -> + happyIn32+ (sL1 happy_var_2 $ DeclD ModuleD happy_var_3 (Just (sL1 happy_var_2 (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7) (snd $ snd happy_var_7) happy_var_4 happy_var_1)))+ ) `HappyStk` happyRest}}}}}}++happyReduce_53 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_53 = happyReduce 7# 16# happyReduction_53+happyReduction_53 (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 happyOut35 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + case happyOut38 happy_x_4 of { happy_var_4 -> + case happyOut48 happy_x_5 of { happy_var_5 -> + case happyOut39 happy_x_7 of { happy_var_7 -> + happyIn32+ (sL1 happy_var_2 $ DeclD SignatureD happy_var_3 (Just (sL1 happy_var_2 (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7) (snd $ snd happy_var_7) happy_var_4 happy_var_1)))+ ) `HappyStk` happyRest}}}}}}++happyReduce_54 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_54 = happySpecReduce_3 16# happyReduction_54+happyReduction_54 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + happyIn32+ (sL1 happy_var_2 $ DeclD ModuleD happy_var_3 Nothing+ )}}++happyReduce_55 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_55 = happySpecReduce_3 16# happyReduction_55+happyReduction_55 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + happyIn32+ (sL1 happy_var_2 $ DeclD SignatureD happy_var_3 Nothing+ )}}++happyReduce_56 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_56 = happySpecReduce_3 16# happyReduction_56+happyReduction_56 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_2 of { happy_var_2 -> + case happyOut27 happy_x_3 of { happy_var_3 -> + happyIn32+ (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_2+ , idModRenaming = happy_var_3+ , idSignatureInclude = False })+ )}}}++happyReduce_57 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_57 = happySpecReduce_3 16# happyReduction_57+happyReduction_57 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_3 of { happy_var_3 -> + happyIn32+ (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_3+ , idModRenaming = Nothing+ , idSignatureInclude = True })+ )}}++happyReduce_58 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_58 = happyMonadReduce 7# 17# happyReduction_58+happyReduction_58 (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 happyOut35 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + case happyOut38 happy_x_4 of { happy_var_4 -> + case happyOut48 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + case happyOut39 happy_x_7 of { happy_var_7 -> + ( fileSrcSpan >>= \ loc ->+ ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)+ (snd $ snd happy_var_7) happy_var_4 happy_var_1)+ )+ ([mj AnnSignature happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})+ ) (\r -> happyReturn (happyIn33 r))++happyReduce_59 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_59 = happyMonadReduce 7# 18# happyReduction_59+happyReduction_59 (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 happyOut35 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + case happyOut38 happy_x_4 of { happy_var_4 -> + case happyOut48 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + case happyOut39 happy_x_7 of { happy_var_7 -> + ( fileSrcSpan >>= \ loc ->+ ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)+ (snd $ snd happy_var_7) happy_var_4 happy_var_1)+ )+ ([mj AnnModule happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})+ ) (\r -> happyReturn (happyIn34 r))++happyReduce_60 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_60 = happyMonadReduce 1# 18# happyReduction_60+happyReduction_60 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut40 happy_x_1 of { happy_var_1 -> + ( fileSrcSpan >>= \ loc ->+ ams (L loc (HsModule Nothing Nothing+ (fst $ snd happy_var_1) (snd $ snd happy_var_1) Nothing Nothing))+ (fst happy_var_1))})+ ) (\r -> happyReturn (happyIn34 r))++happyReduce_61 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_61 = happySpecReduce_1 19# happyReduction_61+happyReduction_61 happy_x_1+ = case happyOut316 happy_x_1 of { happy_var_1 -> + happyIn35+ (happy_var_1+ )}++happyReduce_62 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_62 = happySpecReduce_0 19# happyReduction_62+happyReduction_62 = happyIn35+ (Nothing+ )++happyReduce_63 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_63 = happyMonadReduce 0# 20# happyReduction_63+happyReduction_63 (happyRest) tk+ = happyThen ((( pushModuleContext))+ ) (\r -> happyReturn (happyIn36 r))++happyReduce_64 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_64 = happyMonadReduce 0# 21# happyReduction_64+happyReduction_64 (happyRest) tk+ = happyThen ((( pushModuleContext))+ ) (\r -> happyReturn (happyIn37 r))++happyReduce_65 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_65 = happyMonadReduce 3# 22# happyReduction_65+happyReduction_65 (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 happyOut135 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ajs (Just (sLL happy_var_1 happy_var_3 $ DeprecatedTxt (sL1 happy_var_1 (getDEPRECATED_PRAGs happy_var_1)) (snd $ unLoc happy_var_2)))+ (mo happy_var_1:mc happy_var_3: (fst $ unLoc happy_var_2)))}}})+ ) (\r -> happyReturn (happyIn38 r))++happyReduce_66 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_66 = happyMonadReduce 3# 22# happyReduction_66+happyReduction_66 (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 happyOut135 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ajs (Just (sLL happy_var_1 happy_var_3 $ WarningTxt (sL1 happy_var_1 (getWARNING_PRAGs happy_var_1)) (snd $ unLoc happy_var_2)))+ (mo happy_var_1:mc happy_var_3 : (fst $ unLoc happy_var_2)))}}})+ ) (\r -> happyReturn (happyIn38 r))++happyReduce_67 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_67 = happySpecReduce_0 22# happyReduction_67+happyReduction_67 = happyIn38+ (Nothing+ )++happyReduce_68 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_68 = happySpecReduce_3 23# happyReduction_68+happyReduction_68 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut41 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn39+ ((moc happy_var_1:mcc happy_var_3:(fst happy_var_2)+ , snd happy_var_2)+ )}}}++happyReduce_69 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_69 = happySpecReduce_3 23# happyReduction_69+happyReduction_69 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn39+ ((fst happy_var_2, snd happy_var_2)+ )}++happyReduce_70 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_70 = happySpecReduce_3 24# happyReduction_70+happyReduction_70 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut41 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn40+ ((moc happy_var_1:mcc happy_var_3+ :(fst happy_var_2), snd happy_var_2)+ )}}}++happyReduce_71 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_71 = happySpecReduce_3 24# happyReduction_71+happyReduction_71 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn40+ (([],snd happy_var_2)+ )}++happyReduce_72 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_72 = happySpecReduce_2 25# happyReduction_72+happyReduction_72 happy_x_2+ happy_x_1+ = case happyOut61 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + happyIn41+ ((happy_var_1, happy_var_2)+ )}}++happyReduce_73 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_73 = happySpecReduce_2 26# happyReduction_73+happyReduction_73 happy_x_2+ happy_x_1+ = case happyOut63 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_2 of { happy_var_2 -> + happyIn42+ ((reverse happy_var_1, cvTopDecls happy_var_2)+ )}}++happyReduce_74 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_74 = happySpecReduce_2 26# happyReduction_74+happyReduction_74 happy_x_2+ happy_x_1+ = case happyOut63 happy_x_1 of { happy_var_1 -> + case happyOut75 happy_x_2 of { happy_var_2 -> + happyIn42+ ((reverse happy_var_1, cvTopDecls happy_var_2)+ )}}++happyReduce_75 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_75 = happySpecReduce_1 26# happyReduction_75+happyReduction_75 happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn42+ ((reverse happy_var_1, [])+ )}++happyReduce_76 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_76 = happyMonadReduce 7# 27# happyReduction_76+happyReduction_76 (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 happyOut35 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + case happyOut38 happy_x_4 of { happy_var_4 -> + case happyOut48 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + case happyOut44 happy_x_7 of { happy_var_7 -> + ( fileSrcSpan >>= \ loc ->+ ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1+ )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})+ ) (\r -> happyReturn (happyIn43 r))++happyReduce_77 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_77 = happyMonadReduce 7# 27# happyReduction_77+happyReduction_77 (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 happyOut35 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut308 happy_x_3 of { happy_var_3 -> + case happyOut38 happy_x_4 of { happy_var_4 -> + case happyOut48 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + case happyOut44 happy_x_7 of { happy_var_7 -> + ( fileSrcSpan >>= \ loc ->+ ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1+ )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})+ ) (\r -> happyReturn (happyIn43 r))++happyReduce_78 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_78 = happyMonadReduce 1# 27# happyReduction_78+happyReduction_78 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut45 happy_x_1 of { happy_var_1 -> + ( fileSrcSpan >>= \ loc ->+ return (L loc (HsModule Nothing Nothing happy_var_1 [] Nothing+ Nothing)))})+ ) (\r -> happyReturn (happyIn43 r))++happyReduce_79 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_79 = happySpecReduce_2 28# happyReduction_79+happyReduction_79 happy_x_2+ happy_x_1+ = case happyOut46 happy_x_2 of { happy_var_2 -> + happyIn44+ (happy_var_2+ )}++happyReduce_80 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_80 = happySpecReduce_2 28# happyReduction_80+happyReduction_80 happy_x_2+ happy_x_1+ = case happyOut46 happy_x_2 of { happy_var_2 -> + happyIn44+ (happy_var_2+ )}++happyReduce_81 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_81 = happySpecReduce_2 29# happyReduction_81+happyReduction_81 happy_x_2+ happy_x_1+ = case happyOut46 happy_x_2 of { happy_var_2 -> + happyIn45+ (happy_var_2+ )}++happyReduce_82 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_82 = happySpecReduce_2 29# happyReduction_82+happyReduction_82 happy_x_2+ happy_x_1+ = case happyOut46 happy_x_2 of { happy_var_2 -> + happyIn45+ (happy_var_2+ )}++happyReduce_83 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_83 = happySpecReduce_2 30# happyReduction_83+happyReduction_83 happy_x_2+ happy_x_1+ = case happyOut47 happy_x_2 of { happy_var_2 -> + happyIn46+ (happy_var_2+ )}++happyReduce_84 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_84 = happySpecReduce_1 31# happyReduction_84+happyReduction_84 happy_x_1+ = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn47+ (happy_var_1+ )}++happyReduce_85 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_85 = happySpecReduce_1 31# happyReduction_85+happyReduction_85 happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn47+ (happy_var_1+ )}++happyReduce_86 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_86 = happyMonadReduce 3# 32# happyReduction_86+happyReduction_86 (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 happyOut49 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 ()) [mop happy_var_1,mcp happy_var_3] >>+ return (Just (sLL happy_var_1 happy_var_3 (fromOL happy_var_2))))}}})+ ) (\r -> happyReturn (happyIn48 r))++happyReduce_87 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_87 = happySpecReduce_0 32# happyReduction_87+happyReduction_87 = happyIn48+ (Nothing+ )++happyReduce_88 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_88 = happyMonadReduce 3# 33# happyReduction_88+happyReduction_88 (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 { happy_var_2 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + ( addAnnotation (oll happy_var_1) AnnComma (gl happy_var_2)+ >> return (happy_var_1 `appOL` happy_var_3))}}})+ ) (\r -> happyReturn (happyIn49 r))++happyReduce_89 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_89 = happySpecReduce_1 33# happyReduction_89+happyReduction_89 happy_x_1+ = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn49+ (happy_var_1+ )}++happyReduce_90 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_90 = happyMonadReduce 5# 34# happyReduction_90+happyReduction_90 (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 happyOut53 happy_x_2 of { happy_var_2 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut50 happy_x_5 of { happy_var_5 -> + ( (addAnnotation (oll (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3))+ AnnComma (gl happy_var_4) ) >>+ return (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3 `appOL` happy_var_5))}}}}})+ ) (\r -> happyReturn (happyIn50 r))++happyReduce_91 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_91 = happySpecReduce_3 34# happyReduction_91+happyReduction_91 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut51 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_2 of { happy_var_2 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + happyIn50+ (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3+ )}}}++happyReduce_92 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_92 = happySpecReduce_1 34# happyReduction_92+happyReduction_92 happy_x_1+ = case happyOut51 happy_x_1 of { happy_var_1 -> + happyIn50+ (happy_var_1+ )}++happyReduce_93 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_93 = happySpecReduce_2 35# happyReduction_93+happyReduction_93 happy_x_2+ happy_x_1+ = case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_2 of { happy_var_2 -> + happyIn51+ (happy_var_1 `appOL` happy_var_2+ )}}++happyReduce_94 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_94 = happySpecReduce_0 35# happyReduction_94+happyReduction_94 = happyIn51+ (nilOL+ )++happyReduce_95 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_95 = happySpecReduce_1 36# happyReduction_95+happyReduction_95 happy_x_1+ = case happyOut315 happy_x_1 of { happy_var_1 -> + happyIn52+ (unitOL (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> IEGroup n doc))+ )}++happyReduce_96 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_96 = happySpecReduce_1 36# happyReduction_96+happyReduction_96 happy_x_1+ = case happyOut314 happy_x_1 of { happy_var_1 -> + happyIn52+ (unitOL (sL1 happy_var_1 (IEDocNamed ((fst . unLoc) happy_var_1)))+ )}++happyReduce_97 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_97 = happySpecReduce_1 36# happyReduction_97+happyReduction_97 happy_x_1+ = case happyOut312 happy_x_1 of { happy_var_1 -> + happyIn52+ (unitOL (sL1 happy_var_1 (IEDoc (unLoc happy_var_1)))+ )}++happyReduce_98 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_98 = happyMonadReduce 2# 37# happyReduction_98+happyReduction_98 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut58 happy_x_1 of { happy_var_1 -> + case happyOut54 happy_x_2 of { happy_var_2 -> + ( mkModuleImpExp happy_var_1 (snd $ unLoc happy_var_2)+ >>= \ie -> amsu (sLL happy_var_1 happy_var_2 ie) (fst $ unLoc happy_var_2))}})+ ) (\r -> happyReturn (happyIn53 r))++happyReduce_99 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_99 = happyMonadReduce 2# 37# happyReduction_99+happyReduction_99 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut308 happy_x_2 of { happy_var_2 -> + ( amsu (sLL happy_var_1 happy_var_2 (IEModuleContents happy_var_2))+ [mj AnnModule happy_var_1])}})+ ) (\r -> happyReturn (happyIn53 r))++happyReduce_100 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_100 = happyMonadReduce 2# 37# happyReduction_100+happyReduction_100 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut263 happy_x_2 of { happy_var_2 -> + ( amsu (sLL happy_var_1 happy_var_2 (IEVar (sLL happy_var_1 happy_var_2 (IEPattern happy_var_2))))+ [mj AnnPattern happy_var_1])}})+ ) (\r -> happyReturn (happyIn53 r))++happyReduce_101 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_101 = happySpecReduce_0 38# happyReduction_101+happyReduction_101 = happyIn54+ (sL0 ([],ImpExpAbs)+ )++happyReduce_102 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_102 = happyMonadReduce 3# 38# 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 { happy_var_1 -> + case happyOut55 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( mkImpExpSubSpec (reverse (snd happy_var_2))+ >>= \(as,ie) -> return $ sLL happy_var_1 happy_var_3+ (as ++ [mop happy_var_1,mcp happy_var_3] ++ fst happy_var_2, ie))}}})+ ) (\r -> happyReturn (happyIn54 r))++happyReduce_103 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_103 = happySpecReduce_0 39# happyReduction_103+happyReduction_103 = happyIn55+ (([],[])+ )++happyReduce_104 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_104 = happySpecReduce_1 39# happyReduction_104+happyReduction_104 happy_x_1+ = case happyOut56 happy_x_1 of { happy_var_1 -> + happyIn55+ (happy_var_1+ )}++happyReduce_105 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_105 = happyMonadReduce 3# 40# happyReduction_105+happyReduction_105 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut56 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut57 happy_x_3 of { happy_var_3 -> + ( case (head (snd happy_var_1)) of+ l@(L _ ImpExpQcWildcard) ->+ return ([mj AnnComma happy_var_2, mj AnnDotdot l]+ ,(snd (unLoc happy_var_3) : snd happy_var_1))+ l -> (ams (head (snd happy_var_1)) [mj AnnComma happy_var_2] >>+ return (fst happy_var_1 ++ fst (unLoc happy_var_3),+ snd (unLoc happy_var_3) : snd happy_var_1)))}}})+ ) (\r -> happyReturn (happyIn56 r))++happyReduce_106 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_106 = happySpecReduce_1 40# happyReduction_106+happyReduction_106 happy_x_1+ = case happyOut57 happy_x_1 of { happy_var_1 -> + happyIn56+ ((fst (unLoc happy_var_1),[snd (unLoc happy_var_1)])+ )}++happyReduce_107 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_107 = happySpecReduce_1 41# happyReduction_107+happyReduction_107 happy_x_1+ = case happyOut58 happy_x_1 of { happy_var_1 -> + happyIn57+ (sL1 happy_var_1 ([],happy_var_1)+ )}++happyReduce_108 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_108 = happySpecReduce_1 41# happyReduction_108+happyReduction_108 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn57+ (sL1 happy_var_1 ([mj AnnDotdot happy_var_1], sL1 happy_var_1 ImpExpQcWildcard)+ )}++happyReduce_109 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_109 = happySpecReduce_1 42# happyReduction_109+happyReduction_109 happy_x_1+ = case happyOut59 happy_x_1 of { happy_var_1 -> + happyIn58+ (sL1 happy_var_1 (ImpExpQcName happy_var_1)+ )}++happyReduce_110 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_110 = happyMonadReduce 2# 42# happyReduction_110+happyReduction_110 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut273 happy_x_2 of { happy_var_2 -> + ( do { n <- mkTypeImpExp happy_var_2+ ; ams (sLL happy_var_1 happy_var_2 (ImpExpQcType n))+ [mj AnnType happy_var_1] })}})+ ) (\r -> happyReturn (happyIn58 r))++happyReduce_111 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_111 = happySpecReduce_1 43# happyReduction_111+happyReduction_111 happy_x_1+ = case happyOut292 happy_x_1 of { happy_var_1 -> + happyIn59+ (happy_var_1+ )}++happyReduce_112 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_112 = happySpecReduce_1 43# happyReduction_112+happyReduction_112 happy_x_1+ = case happyOut274 happy_x_1 of { happy_var_1 -> + happyIn59+ (happy_var_1+ )}++happyReduce_113 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_113 = happySpecReduce_2 44# happyReduction_113+happyReduction_113 happy_x_2+ happy_x_1+ = case happyOut60 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn60+ (mj AnnSemi happy_var_2 : happy_var_1+ )}}++happyReduce_114 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_114 = happySpecReduce_1 44# happyReduction_114+happyReduction_114 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn60+ ([mj AnnSemi happy_var_1]+ )}++happyReduce_115 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_115 = happySpecReduce_2 45# happyReduction_115+happyReduction_115 happy_x_2+ happy_x_1+ = case happyOut61 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn61+ (mj AnnSemi happy_var_2 : happy_var_1+ )}}++happyReduce_116 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_116 = happySpecReduce_0 45# happyReduction_116+happyReduction_116 = happyIn61+ ([]+ )++happyReduce_117 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_117 = happySpecReduce_2 46# happyReduction_117+happyReduction_117 happy_x_2+ happy_x_1+ = case happyOut63 happy_x_1 of { happy_var_1 -> + case happyOut64 happy_x_2 of { happy_var_2 -> + happyIn62+ (happy_var_2 : happy_var_1+ )}}++happyReduce_118 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_118 = happyMonadReduce 3# 47# happyReduction_118+happyReduction_118 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut63 happy_x_1 of { happy_var_1 -> + case happyOut64 happy_x_2 of { happy_var_2 -> + case happyOut60 happy_x_3 of { happy_var_3 -> + ( ams happy_var_2 happy_var_3 >> return (happy_var_2 : happy_var_1))}}})+ ) (\r -> happyReturn (happyIn63 r))++happyReduce_119 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_119 = happySpecReduce_0 47# happyReduction_119+happyReduction_119 = happyIn63+ ([]+ )++happyReduce_120 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_120 = happyMonadReduce 8# 48# happyReduction_120+happyReduction_120 (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 { happy_var_1 -> + case happyOut65 happy_x_2 of { happy_var_2 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + case happyOut68 happy_x_4 of { happy_var_4 -> + case happyOut67 happy_x_5 of { happy_var_5 -> + case happyOut308 happy_x_6 of { happy_var_6 -> + case happyOut69 happy_x_7 of { happy_var_7 -> + case happyOut70 happy_x_8 of { happy_var_8 -> + ( ams (L (comb4 happy_var_1 happy_var_6 (snd happy_var_7) happy_var_8) $+ ImportDecl { ideclSourceSrc = snd $ fst happy_var_2+ , ideclName = happy_var_6, ideclPkgQual = snd happy_var_5+ , ideclSource = snd happy_var_2, ideclSafe = snd happy_var_3+ , ideclQualified = snd happy_var_4, ideclImplicit = False+ , ideclAs = unLoc (snd happy_var_7)+ , ideclHiding = unLoc happy_var_8 })+ ((mj AnnImport happy_var_1 : (fst $ fst happy_var_2) ++ fst happy_var_3 ++ fst happy_var_4+ ++ fst happy_var_5 ++ fst happy_var_7)))}}}}}}}})+ ) (\r -> happyReturn (happyIn64 r))++happyReduce_121 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_121 = happySpecReduce_2 49# happyReduction_121+happyReduction_121 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn65+ ((([mo happy_var_1,mc happy_var_2],getSOURCE_PRAGs happy_var_1)+ ,True)+ )}}++happyReduce_122 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_122 = happySpecReduce_0 49# happyReduction_122+happyReduction_122 = happyIn65+ ((([],NoSourceText),False)+ )++happyReduce_123 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_123 = happySpecReduce_1 50# happyReduction_123+happyReduction_123 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn66+ (([mj AnnSafe happy_var_1],True)+ )}++happyReduce_124 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_124 = happySpecReduce_0 50# happyReduction_124+happyReduction_124 = happyIn66+ (([],False)+ )++happyReduce_125 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_125 = happyMonadReduce 1# 51# happyReduction_125+happyReduction_125 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( let pkgFS = getSTRING happy_var_1 in+ if looksLikePackageName (unpackFS pkgFS)+ then return ([mj AnnPackageName happy_var_1], Just (StringLiteral (getSTRINGs happy_var_1) pkgFS))+ else parseErrorSDoc (getLoc happy_var_1) $ vcat [+ text "parse error" <> colon <+> quotes (ppr pkgFS),+ text "Version number or non-alphanumeric" <+>+ text "character in package name"])})+ ) (\r -> happyReturn (happyIn67 r))++happyReduce_126 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_126 = happySpecReduce_0 51# happyReduction_126+happyReduction_126 = happyIn67+ (([],Nothing)+ )++happyReduce_127 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_127 = happySpecReduce_1 52# happyReduction_127+happyReduction_127 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn68+ (([mj AnnQualified happy_var_1],True)+ )}++happyReduce_128 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_128 = happySpecReduce_0 52# happyReduction_128+happyReduction_128 = happyIn68+ (([],False)+ )++happyReduce_129 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_129 = happySpecReduce_2 53# happyReduction_129+happyReduction_129 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut308 happy_x_2 of { happy_var_2 -> + happyIn69+ (([mj AnnAs happy_var_1]+ ,sLL happy_var_1 happy_var_2 (Just happy_var_2))+ )}}++happyReduce_130 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_130 = happySpecReduce_0 53# happyReduction_130+happyReduction_130 = happyIn69+ (([],noLoc Nothing)+ )++happyReduce_131 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_131 = happyMonadReduce 1# 54# happyReduction_131+happyReduction_131 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut71 happy_x_1 of { happy_var_1 -> + ( let (b, ie) = unLoc happy_var_1 in+ checkImportSpec ie+ >>= \checkedIe ->+ return (L (gl happy_var_1) (Just (b, checkedIe))))})+ ) (\r -> happyReturn (happyIn70 r))++happyReduce_132 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_132 = happySpecReduce_0 54# happyReduction_132+happyReduction_132 = happyIn70+ (noLoc Nothing+ )++happyReduce_133 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_133 = happyMonadReduce 3# 55# happyReduction_133+happyReduction_133 (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 happyOut49 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (False,+ sLL happy_var_1 happy_var_3 $ fromOL happy_var_2))+ [mop happy_var_1,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn71 r))++happyReduce_134 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_134 = happyMonadReduce 4# 55# happyReduction_134+happyReduction_134 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut49 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 (True,+ sLL happy_var_1 happy_var_4 $ fromOL happy_var_3))+ [mj AnnHiding happy_var_1,mop happy_var_2,mcp happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn71 r))++happyReduce_135 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_135 = happySpecReduce_0 56# happyReduction_135+happyReduction_135 = happyIn72+ (noLoc (NoSourceText,9)+ )++happyReduce_136 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_136 = happyMonadReduce 1# 56# happyReduction_136+happyReduction_136 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( checkPrecP (sL1 happy_var_1 (getINTEGERs happy_var_1,fromInteger (il_value (getINTEGER happy_var_1)))))})+ ) (\r -> happyReturn (happyIn72 r))++happyReduce_137 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_137 = happySpecReduce_1 57# happyReduction_137+happyReduction_137 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn73+ (sL1 happy_var_1 InfixN+ )}++happyReduce_138 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_138 = happySpecReduce_1 57# happyReduction_138+happyReduction_138 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn73+ (sL1 happy_var_1 InfixL+ )}++happyReduce_139 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_139 = happySpecReduce_1 57# happyReduction_139+happyReduction_139 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn73+ (sL1 happy_var_1 InfixR+ )}++happyReduce_140 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_140 = happyMonadReduce 3# 58# happyReduction_140+happyReduction_140 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut74 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut281 happy_x_3 of { happy_var_3 -> + ( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 ((unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn74 r))++happyReduce_141 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_141 = happySpecReduce_1 58# happyReduction_141+happyReduction_141 happy_x_1+ = case happyOut281 happy_x_1 of { happy_var_1 -> + happyIn74+ (sL1 happy_var_1 (unitOL happy_var_1)+ )}++happyReduce_142 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_142 = happySpecReduce_2 59# happyReduction_142+happyReduction_142 happy_x_2+ happy_x_1+ = case happyOut76 happy_x_1 of { happy_var_1 -> + case happyOut77 happy_x_2 of { happy_var_2 -> + happyIn75+ (happy_var_1 `snocOL` happy_var_2+ )}}++happyReduce_143 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_143 = happyMonadReduce 3# 60# happyReduction_143+happyReduction_143 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut76 happy_x_1 of { happy_var_1 -> + case happyOut77 happy_x_2 of { happy_var_2 -> + case happyOut60 happy_x_3 of { happy_var_3 -> + ( ams happy_var_2 happy_var_3 >> return (happy_var_1 `snocOL` happy_var_2))}}})+ ) (\r -> happyReturn (happyIn76 r))++happyReduce_144 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_144 = happySpecReduce_0 60# happyReduction_144+happyReduction_144 = happyIn76+ (nilOL+ )++happyReduce_145 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_145 = happySpecReduce_1 61# happyReduction_145+happyReduction_145 happy_x_1+ = case happyOut78 happy_x_1 of { happy_var_1 -> + happyIn77+ (sL1 happy_var_1 (TyClD (unLoc happy_var_1))+ )}++happyReduce_146 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_146 = happySpecReduce_1 61# happyReduction_146+happyReduction_146 happy_x_1+ = case happyOut79 happy_x_1 of { happy_var_1 -> + happyIn77+ (sL1 happy_var_1 (TyClD (unLoc happy_var_1))+ )}++happyReduce_147 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_147 = happySpecReduce_1 61# happyReduction_147+happyReduction_147 happy_x_1+ = case happyOut80 happy_x_1 of { happy_var_1 -> + happyIn77+ (sL1 happy_var_1 (InstD (unLoc happy_var_1))+ )}++happyReduce_148 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_148 = happySpecReduce_1 61# happyReduction_148+happyReduction_148 happy_x_1+ = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn77+ (sLL happy_var_1 happy_var_1 (DerivD (unLoc happy_var_1))+ )}++happyReduce_149 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_149 = happySpecReduce_1 61# happyReduction_149+happyReduction_149 happy_x_1+ = case happyOut102 happy_x_1 of { happy_var_1 -> + happyIn77+ (sL1 happy_var_1 (RoleAnnotD (unLoc happy_var_1))+ )}++happyReduce_150 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_150 = happyMonadReduce 4# 61# happyReduction_150+happyReduction_150 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut164 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 (DefD (DefaultDecl happy_var_3)))+ [mj AnnDefault happy_var_1+ ,mop happy_var_2,mcp happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_151 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_151 = happyMonadReduce 2# 61# happyReduction_151+happyReduction_151 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut138 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 (snd $ unLoc happy_var_2))+ (mj AnnForeign happy_var_1:(fst $ unLoc happy_var_2)))}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_152 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_152 = happyMonadReduce 3# 61# happyReduction_152+happyReduction_152 (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 happyOut133 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ WarningD (Warnings (getDEPRECATED_PRAGs happy_var_1) (fromOL happy_var_2)))+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_153 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_153 = happyMonadReduce 3# 61# happyReduction_153+happyReduction_153 (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 happyOut131 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ WarningD (Warnings (getWARNING_PRAGs happy_var_1) (fromOL happy_var_2)))+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_154 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_154 = happyMonadReduce 3# 61# happyReduction_154+happyReduction_154 (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 happyOut124 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ RuleD (HsRules (getRULES_PRAGs happy_var_1) (fromOL happy_var_2)))+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_155 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_155 = happyMonadReduce 5# 61# happyReduction_155+happyReduction_155 (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 happyOut292 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( ams (sLL happy_var_1 happy_var_5 $ VectD (HsVect (getVECT_PRAGs happy_var_1) happy_var_2 happy_var_4))+ [mo happy_var_1,mj AnnEqual happy_var_3+ ,mc happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_156 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_156 = happyMonadReduce 3# 61# happyReduction_156+happyReduction_156 (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 happyOut292 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ VectD (HsNoVect (getNOVECT_PRAGs happy_var_1) happy_var_2))+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_157 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_157 = happyMonadReduce 4# 61# happyReduction_157+happyReduction_157 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut271 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $+ VectD (HsVectTypeIn (getVECT_PRAGs happy_var_1) False happy_var_3 Nothing))+ [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_158 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_158 = happyMonadReduce 4# 61# happyReduction_158+happyReduction_158 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut271 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $+ VectD (HsVectTypeIn (getVECT_SCALAR_PRAGs happy_var_1) True happy_var_3 Nothing))+ [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_159 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_159 = happyMonadReduce 6# 61# happyReduction_159+happyReduction_159 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut271 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut271 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + ( ams (sLL happy_var_1 happy_var_6 $+ VectD (HsVectTypeIn (getVECT_PRAGs happy_var_1) False happy_var_3 (Just happy_var_5)))+ [mo happy_var_1,mj AnnType happy_var_2,mj AnnEqual happy_var_4,mc happy_var_6])}}}}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_160 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_160 = happyMonadReduce 6# 61# 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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut271 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut271 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + ( ams (sLL happy_var_1 happy_var_6 $+ VectD (HsVectTypeIn (getVECT_SCALAR_PRAGs happy_var_1) True happy_var_3 (Just happy_var_5)))+ [mo happy_var_1,mj AnnType happy_var_2,mj AnnEqual happy_var_4,mc happy_var_6])}}}}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_161 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_161 = happyMonadReduce 4# 61# happyReduction_161+happyReduction_161 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut271 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $ VectD (HsVectClassIn (getVECT_PRAGs happy_var_1) happy_var_3))+ [mo happy_var_1,mj AnnClass happy_var_2,mc happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn77 r))++happyReduce_162 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_162 = happySpecReduce_1 61# happyReduction_162+happyReduction_162 happy_x_1+ = case happyOut137 happy_x_1 of { happy_var_1 -> + happyIn77+ (happy_var_1+ )}++happyReduce_163 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_163 = happySpecReduce_1 61# happyReduction_163+happyReduction_163 happy_x_1+ = case happyOut191 happy_x_1 of { happy_var_1 -> + happyIn77+ (happy_var_1+ )}++happyReduce_164 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_164 = happySpecReduce_1 61# happyReduction_164+happyReduction_164 happy_x_1+ = case happyOut202 happy_x_1 of { happy_var_1 -> + happyIn77+ (sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1+ )}++happyReduce_165 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_165 = happyMonadReduce 4# 62# happyReduction_165+happyReduction_165 (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 happyOut99 happy_x_2 of { happy_var_2 -> + case happyOut169 happy_x_3 of { happy_var_3 -> + case happyOut115 happy_x_4 of { happy_var_4 -> + ( amms (mkClassDecl (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4) happy_var_2 happy_var_3 (snd $ unLoc happy_var_4))+ (mj AnnClass happy_var_1:(fst $ unLoc happy_var_3)++(fst $ unLoc happy_var_4)))}}}})+ ) (\r -> happyReturn (happyIn78 r))++happyReduce_166 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_166 = happyMonadReduce 4# 63# happyReduction_166+happyReduction_166 (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 happyOut155 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut152 happy_x_4 of { happy_var_4 -> + ( amms (mkTySynonym (comb2 happy_var_1 happy_var_4) happy_var_2 happy_var_4)+ [mj AnnType happy_var_1,mj AnnEqual happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_167 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_167 = happyMonadReduce 6# 63# happyReduction_167+happyReduction_167 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + case happyOut97 happy_x_4 of { happy_var_4 -> + case happyOut83 happy_x_5 of { happy_var_5 -> + case happyOut86 happy_x_6 of { happy_var_6 -> + ( amms (mkFamDecl (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_6) happy_var_3+ (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5))+ (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)+ ++ (fst $ unLoc happy_var_5) ++ (fst $ unLoc happy_var_6)))}}}}}})+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_168 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_168 = happyMonadReduce 5# 63# happyReduction_168+happyReduction_168 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut94 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut99 happy_x_3 of { happy_var_3 -> + case happyOut178 happy_x_4 of { happy_var_4 -> + case happyOut186 happy_x_5 of { happy_var_5 -> + ( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3+ Nothing (reverse (snd $ unLoc happy_var_4))+ (fmap reverse happy_var_5))+ -- We need the location on tycl_hdr in case+ -- constrs and deriving are both empty+ ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)))}}}}})+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_169 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_169 = happyMonadReduce 6# 63# happyReduction_169+happyReduction_169 (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 happyOut94 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut99 happy_x_3 of { happy_var_3 -> + case happyOut95 happy_x_4 of { happy_var_4 -> + case happyOut174 happy_x_5 of { happy_var_5 -> + case happyOut186 happy_x_6 of { happy_var_6 -> + ( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3+ (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)+ (fmap reverse happy_var_6) )+ -- We need the location on tycl_hdr in case+ -- constrs and deriving are both empty+ ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_170 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_170 = happyMonadReduce 4# 63# happyReduction_170+happyReduction_170 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + case happyOut96 happy_x_4 of { happy_var_4 -> + ( amms (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_4) DataFamily happy_var_3+ (snd $ unLoc happy_var_4) Nothing)+ (mj AnnData happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_171 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_171 = happyMonadReduce 4# 64# happyReduction_171+happyReduction_171 (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 happyOut81 happy_x_2 of { happy_var_2 -> + case happyOut162 happy_x_3 of { happy_var_3 -> + case happyOut119 happy_x_4 of { happy_var_4 -> + ( do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc happy_var_4)+ ; let cid = ClsInstDecl { cid_poly_ty = happy_var_3, cid_binds = binds+ , cid_sigs = mkClassOpSigs sigs+ , cid_tyfam_insts = ats+ , cid_overlap_mode = happy_var_2+ , cid_datafam_insts = adts }+ ; ams (L (comb3 happy_var_1 (hsSigType happy_var_3) happy_var_4) (ClsInstD { cid_inst = cid }))+ (mj AnnInstance happy_var_1 : (fst $ unLoc happy_var_4)) })}}}})+ ) (\r -> happyReturn (happyIn80 r))++happyReduce_172 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_172 = happyMonadReduce 3# 64# happyReduction_172+happyReduction_172 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut89 happy_x_3 of { happy_var_3 -> + ( ams happy_var_3 (fst $ unLoc happy_var_3)+ >> amms (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3))+ (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn80 r))++happyReduce_173 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_173 = happyMonadReduce 6# 64# happyReduction_173+happyReduction_173 (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 happyOut94 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + case happyOut99 happy_x_4 of { happy_var_4 -> + case happyOut178 happy_x_5 of { happy_var_5 -> + case happyOut186 happy_x_6 of { happy_var_6 -> + ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 happy_var_4+ Nothing (reverse (snd $ unLoc happy_var_5))+ (fmap reverse happy_var_6))+ ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2:(fst $ unLoc happy_var_5)))}}}}}})+ ) (\r -> happyReturn (happyIn80 r))++happyReduce_174 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_174 = happyMonadReduce 7# 64# happyReduction_174+happyReduction_174 (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 happyOut94 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + case happyOut99 happy_x_4 of { happy_var_4 -> + case happyOut95 happy_x_5 of { happy_var_5 -> + case happyOut174 happy_x_6 of { happy_var_6 -> + case happyOut186 happy_x_7 of { happy_var_7 -> + ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3 happy_var_4+ (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)+ (fmap reverse happy_var_7))+ ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2+ :(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})+ ) (\r -> happyReturn (happyIn80 r))++happyReduce_175 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_175 = happyMonadReduce 2# 65# happyReduction_175+happyReduction_175 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ajs (Just (sLL happy_var_1 happy_var_2 (Overlappable (getOVERLAPPABLE_PRAGs happy_var_1))))+ [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn81 r))++happyReduce_176 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_176 = happyMonadReduce 2# 65# happyReduction_176+happyReduction_176 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ajs (Just (sLL happy_var_1 happy_var_2 (Overlapping (getOVERLAPPING_PRAGs happy_var_1))))+ [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn81 r))++happyReduce_177 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_177 = happyMonadReduce 2# 65# happyReduction_177+happyReduction_177 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ajs (Just (sLL happy_var_1 happy_var_2 (Overlaps (getOVERLAPS_PRAGs happy_var_1))))+ [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn81 r))++happyReduce_178 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+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 { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ajs (Just (sLL happy_var_1 happy_var_2 (Incoherent (getINCOHERENT_PRAGs happy_var_1))))+ [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn81 r))++happyReduce_179 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_179 = happySpecReduce_0 65# happyReduction_179+happyReduction_179 = happyIn81+ (Nothing+ )++happyReduce_180 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_180 = happyMonadReduce 1# 66# happyReduction_180+happyReduction_180 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( ajs (Just (sL1 happy_var_1 StockStrategy))+ [mj AnnStock happy_var_1])})+ ) (\r -> happyReturn (happyIn82 r))++happyReduce_181 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_181 = happyMonadReduce 1# 66# happyReduction_181+happyReduction_181 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( ajs (Just (sL1 happy_var_1 AnyclassStrategy))+ [mj AnnAnyclass happy_var_1])})+ ) (\r -> happyReturn (happyIn82 r))++happyReduce_182 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_182 = happyMonadReduce 1# 66# happyReduction_182+happyReduction_182 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( ajs (Just (sL1 happy_var_1 NewtypeStrategy))+ [mj AnnNewtype happy_var_1])})+ ) (\r -> happyReturn (happyIn82 r))++happyReduce_183 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_183 = happySpecReduce_0 66# happyReduction_183+happyReduction_183 = happyIn82+ (Nothing+ )++happyReduce_184 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_184 = happySpecReduce_0 67# happyReduction_184+happyReduction_184 = happyIn83+ (noLoc ([], Nothing)+ )++happyReduce_185 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_185 = happySpecReduce_2 67# happyReduction_185+happyReduction_185 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + happyIn83+ (sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]+ , Just (happy_var_2))+ )}}++happyReduce_186 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_186 = happyMonadReduce 3# 68# happyReduction_186+happyReduction_186 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut290 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (InjectivityAnn happy_var_1 (reverse (unLoc happy_var_3))))+ [mu AnnRarrow happy_var_2])}}})+ ) (\r -> happyReturn (happyIn84 r))++happyReduce_187 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_187 = happySpecReduce_2 69# happyReduction_187+happyReduction_187 happy_x_2+ happy_x_1+ = case happyOut85 happy_x_1 of { happy_var_1 -> + case happyOut290 happy_x_2 of { happy_var_2 -> + happyIn85+ (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)+ )}}++happyReduce_188 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_188 = happySpecReduce_1 69# happyReduction_188+happyReduction_188 happy_x_1+ = case happyOut290 happy_x_1 of { happy_var_1 -> + happyIn85+ (sLL happy_var_1 happy_var_1 [happy_var_1]+ )}++happyReduce_189 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_189 = happySpecReduce_0 70# happyReduction_189+happyReduction_189 = happyIn86+ (noLoc ([],OpenTypeFamily)+ )++happyReduce_190 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_190 = happySpecReduce_2 70# happyReduction_190+happyReduction_190 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn86+ (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)+ ,ClosedTypeFamily (fmap reverse $ snd $ unLoc happy_var_2))+ )}}++happyReduce_191 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_191 = happySpecReduce_3 71# happyReduction_191+happyReduction_191 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut88 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn87+ (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]+ ,Just (unLoc happy_var_2))+ )}}}++happyReduce_192 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_192 = happySpecReduce_3 71# happyReduction_192+happyReduction_192 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut88 happy_x_2 of { happy_var_2 -> + happyIn87+ (let L loc _ = happy_var_2 in+ L loc ([],Just (unLoc happy_var_2))+ )}++happyReduce_193 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_193 = happySpecReduce_3 71# happyReduction_193+happyReduction_193 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn87+ (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mj AnnDotdot happy_var_2+ ,mcc happy_var_3],Nothing)+ )}}}++happyReduce_194 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_194 = happySpecReduce_3 71# happyReduction_194+happyReduction_194 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn87+ (let L loc _ = happy_var_2 in+ L loc ([mj AnnDotdot happy_var_2],Nothing)+ )}++happyReduce_195 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_195 = happyMonadReduce 3# 72# happyReduction_195+happyReduction_195 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut88 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut89 happy_x_3 of { happy_var_3 -> + ( let L loc (anns, eqn) = happy_var_3 in+ asl (unLoc happy_var_1) happy_var_2 (L loc eqn)+ >> ams happy_var_3 anns+ >> return (sLL happy_var_1 happy_var_3 (L loc eqn : unLoc happy_var_1)))}}})+ ) (\r -> happyReturn (happyIn88 r))++happyReduce_196 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_196 = happyMonadReduce 2# 72# happyReduction_196+happyReduction_196 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut88 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)+ >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+ ) (\r -> happyReturn (happyIn88 r))++happyReduce_197 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_197 = happyMonadReduce 1# 72# happyReduction_197+happyReduction_197 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut89 happy_x_1 of { happy_var_1 -> + ( let L loc (anns, eqn) = happy_var_1 in+ ams happy_var_1 anns+ >> return (sLL happy_var_1 happy_var_1 [L loc eqn]))})+ ) (\r -> happyReturn (happyIn88 r))++happyReduce_198 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_198 = happySpecReduce_0 72# happyReduction_198+happyReduction_198 = happyIn88+ (noLoc []+ )++happyReduce_199 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_199 = happyMonadReduce 3# 73# happyReduction_199+happyReduction_199 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut155 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut151 happy_x_3 of { happy_var_3 -> + ( do { (eqn,ann) <- mkTyFamInstEqn happy_var_1 happy_var_3+ ; return (sLL happy_var_1 happy_var_3 (mj AnnEqual happy_var_2:ann, eqn)) })}}})+ ) (\r -> happyReturn (happyIn89 r))++happyReduce_200 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_200 = happyMonadReduce 4# 74# happyReduction_200+happyReduction_200 (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 happyOut91 happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + case happyOut96 happy_x_4 of { happy_var_4 -> + ( amms (liftM mkTyClD (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) DataFamily happy_var_3+ (snd $ unLoc happy_var_4) Nothing))+ (mj AnnData happy_var_1:happy_var_2++(fst $ unLoc happy_var_4)))}}}})+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_201 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_201 = happyMonadReduce 3# 74# happyReduction_201+happyReduction_201 (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 happyOut155 happy_x_2 of { happy_var_2 -> + case happyOut98 happy_x_3 of { happy_var_3 -> + ( amms (liftM mkTyClD+ (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_3) OpenTypeFamily happy_var_2+ (fst . snd $ unLoc happy_var_3)+ (snd . snd $ unLoc happy_var_3)))+ (mj AnnType happy_var_1:(fst $ unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_202 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_202 = happyMonadReduce 4# 74# happyReduction_202+happyReduction_202 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + case happyOut98 happy_x_4 of { happy_var_4 -> + ( amms (liftM mkTyClD+ (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) OpenTypeFamily happy_var_3+ (fst . snd $ unLoc happy_var_4)+ (snd . snd $ unLoc happy_var_4)))+ (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_203 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_203 = happyMonadReduce 2# 74# happyReduction_203+happyReduction_203 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut89 happy_x_2 of { happy_var_2 -> + ( ams happy_var_2 (fst $ unLoc happy_var_2) >>+ amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_2) (snd $ unLoc happy_var_2)))+ (mj AnnType happy_var_1:(fst $ unLoc happy_var_2)))}})+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_204 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_204 = happyMonadReduce 3# 74# happyReduction_204+happyReduction_204 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut89 happy_x_3 of { happy_var_3 -> + ( ams happy_var_3 (fst $ unLoc happy_var_3) >>+ amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3)))+ (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_205 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_205 = happySpecReduce_0 75# happyReduction_205+happyReduction_205 = happyIn91+ ([]+ )++happyReduce_206 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_206 = happySpecReduce_1 75# happyReduction_206+happyReduction_206 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn91+ ([mj AnnFamily happy_var_1]+ )}++happyReduce_207 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_207 = happySpecReduce_0 76# happyReduction_207+happyReduction_207 = happyIn92+ ([]+ )++happyReduce_208 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_208 = happySpecReduce_1 76# happyReduction_208+happyReduction_208 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn92+ ([mj AnnInstance happy_var_1]+ )}++happyReduce_209 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_209 = happyMonadReduce 3# 77# happyReduction_209+happyReduction_209 (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 happyOut92 happy_x_2 of { happy_var_2 -> + case happyOut89 happy_x_3 of { happy_var_3 -> + ( ams happy_var_3 (fst $ unLoc happy_var_3) >>+ amms (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3))+ (mj AnnType happy_var_1:happy_var_2++(fst $ unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn93 r))++happyReduce_210 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_210 = happyMonadReduce 5# 77# happyReduction_210+happyReduction_210 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut94 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut99 happy_x_3 of { happy_var_3 -> + case happyOut178 happy_x_4 of { happy_var_4 -> + case happyOut186 happy_x_5 of { happy_var_5 -> + ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3+ Nothing (reverse (snd $ unLoc happy_var_4))+ (fmap reverse happy_var_5))+ ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)))}}}}})+ ) (\r -> happyReturn (happyIn93 r))++happyReduce_211 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_211 = happyMonadReduce 6# 77# happyReduction_211+happyReduction_211 (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 happyOut94 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + case happyOut99 happy_x_4 of { happy_var_4 -> + case happyOut178 happy_x_5 of { happy_var_5 -> + case happyOut186 happy_x_6 of { happy_var_6 -> + ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 happy_var_4+ Nothing (reverse (snd $ unLoc happy_var_5))+ (fmap reverse happy_var_6))+ ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2:(fst $ unLoc happy_var_5)))}}}}}})+ ) (\r -> happyReturn (happyIn93 r))++happyReduce_212 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_212 = happyMonadReduce 6# 77# happyReduction_212+happyReduction_212 (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 happyOut94 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut99 happy_x_3 of { happy_var_3 -> + case happyOut95 happy_x_4 of { happy_var_4 -> + case happyOut174 happy_x_5 of { happy_var_5 -> + case happyOut186 happy_x_6 of { happy_var_6 -> + ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_3 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_2+ happy_var_3 (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)+ (fmap reverse happy_var_6))+ ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})+ ) (\r -> happyReturn (happyIn93 r))++happyReduce_213 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_213 = happyMonadReduce 7# 77# happyReduction_213+happyReduction_213 (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 happyOut94 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + case happyOut99 happy_x_4 of { happy_var_4 -> + case happyOut95 happy_x_5 of { happy_var_5 -> + case happyOut174 happy_x_6 of { happy_var_6 -> + case happyOut186 happy_x_7 of { happy_var_7 -> + ( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3+ happy_var_4 (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)+ (fmap reverse happy_var_7))+ ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2:(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})+ ) (\r -> happyReturn (happyIn93 r))++happyReduce_214 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_214 = happySpecReduce_1 78# happyReduction_214+happyReduction_214 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn94+ (sL1 happy_var_1 (mj AnnData happy_var_1,DataType)+ )}++happyReduce_215 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_215 = happySpecReduce_1 78# happyReduction_215+happyReduction_215 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn94+ (sL1 happy_var_1 (mj AnnNewtype happy_var_1,NewType)+ )}++happyReduce_216 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_216 = happySpecReduce_0 79# happyReduction_216+happyReduction_216 = happyIn95+ (noLoc ([] , Nothing)+ )++happyReduce_217 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_217 = happySpecReduce_2 79# happyReduction_217+happyReduction_217 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut173 happy_x_2 of { happy_var_2 -> + happyIn95+ (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], Just happy_var_2)+ )}}++happyReduce_218 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_218 = happySpecReduce_0 80# happyReduction_218+happyReduction_218 = happyIn96+ (noLoc ([] , noLoc NoSig )+ )++happyReduce_219 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_219 = happySpecReduce_2 80# happyReduction_219+happyReduction_219 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut173 happy_x_2 of { happy_var_2 -> + happyIn96+ (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig happy_var_2))+ )}}++happyReduce_220 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_220 = happySpecReduce_0 81# happyReduction_220+happyReduction_220 = happyIn97+ (noLoc ([] , noLoc NoSig )+ )++happyReduce_221 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_221 = happySpecReduce_2 81# happyReduction_221+happyReduction_221 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut173 happy_x_2 of { happy_var_2 -> + happyIn97+ (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig happy_var_2))+ )}}++happyReduce_222 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_222 = happySpecReduce_2 81# happyReduction_222+happyReduction_222 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut168 happy_x_2 of { happy_var_2 -> + happyIn97+ (sLL happy_var_1 happy_var_2 ([mj AnnEqual happy_var_1] , sLL happy_var_1 happy_var_2 (TyVarSig happy_var_2))+ )}}++happyReduce_223 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_223 = happySpecReduce_0 82# happyReduction_223+happyReduction_223 = happyIn98+ (noLoc ([], (noLoc NoSig, Nothing))+ )++happyReduce_224 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_224 = happySpecReduce_2 82# happyReduction_224+happyReduction_224 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut173 happy_x_2 of { happy_var_2 -> + happyIn98+ (sLL happy_var_1 happy_var_2 ( [mu AnnDcolon happy_var_1]+ , (sLL happy_var_2 happy_var_2 (KindSig happy_var_2), Nothing))+ )}}++happyReduce_225 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_225 = happyReduce 4# 82# happyReduction_225+happyReduction_225 (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 happyOut168 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut84 happy_x_4 of { happy_var_4 -> + happyIn98+ (sLL happy_var_1 happy_var_4 ([mj AnnEqual happy_var_1, mj AnnVbar happy_var_3]+ , (sLL happy_var_1 happy_var_2 (TyVarSig happy_var_2), Just happy_var_4))+ ) `HappyStk` happyRest}}}}++happyReduce_226 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_226 = happyMonadReduce 3# 83# happyReduction_226+happyReduction_226 (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 { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)+ >> (return (sLL happy_var_1 happy_var_3 (Just happy_var_1, happy_var_3))))}}})+ ) (\r -> happyReturn (happyIn99 r))++happyReduce_227 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_227 = happySpecReduce_1 83# happyReduction_227+happyReduction_227 happy_x_1+ = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn99+ (sL1 happy_var_1 (Nothing, happy_var_1)+ )}++happyReduce_228 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_228 = happyMonadReduce 4# 84# happyReduction_228+happyReduction_228 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ajs (Just (sLL happy_var_1 happy_var_4 (CType (getCTYPEs happy_var_1) (Just (Header (getSTRINGs happy_var_2) (getSTRING happy_var_2)))+ (getSTRINGs happy_var_3,getSTRING happy_var_3))))+ [mo happy_var_1,mj AnnHeader happy_var_2,mj AnnVal happy_var_3,mc happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn100 r))++happyReduce_229 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_229 = happyMonadReduce 3# 84# happyReduction_229+happyReduction_229 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ajs (Just (sLL happy_var_1 happy_var_3 (CType (getCTYPEs happy_var_1) Nothing (getSTRINGs happy_var_2, getSTRING happy_var_2))))+ [mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn100 r))++happyReduce_230 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_230 = happySpecReduce_0 84# happyReduction_230+happyReduction_230 = happyIn100+ (Nothing+ )++happyReduce_231 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_231 = happyMonadReduce 5# 85# happyReduction_231+happyReduction_231 (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 happyOut82 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut81 happy_x_4 of { happy_var_4 -> + case happyOut162 happy_x_5 of { happy_var_5 -> + ( do { let { err = text "in the stand-alone deriving instance"+ <> colon <+> quotes (ppr happy_var_5) }+ ; ams (sLL happy_var_1 (hsSigType happy_var_5) (DerivDecl happy_var_5 happy_var_2 happy_var_4))+ [mj AnnDeriving happy_var_1, mj AnnInstance happy_var_3] })}}}}})+ ) (\r -> happyReturn (happyIn101 r))++happyReduce_232 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_232 = happyMonadReduce 4# 86# 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 { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut273 happy_x_3 of { happy_var_3 -> + case happyOut103 happy_x_4 of { happy_var_4 -> + ( amms (mkRoleAnnotDecl (comb3 happy_var_1 happy_var_3 happy_var_4) happy_var_3 (reverse (unLoc happy_var_4)))+ [mj AnnType happy_var_1,mj AnnRole happy_var_2])}}}})+ ) (\r -> happyReturn (happyIn102 r))++happyReduce_233 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_233 = happySpecReduce_0 87# happyReduction_233+happyReduction_233 = happyIn103+ (noLoc []+ )++happyReduce_234 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_234 = happySpecReduce_1 87# happyReduction_234+happyReduction_234 happy_x_1+ = case happyOut104 happy_x_1 of { happy_var_1 -> + happyIn103+ (happy_var_1+ )}++happyReduce_235 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_235 = happySpecReduce_1 88# happyReduction_235+happyReduction_235 happy_x_1+ = case happyOut105 happy_x_1 of { happy_var_1 -> + happyIn104+ (sLL happy_var_1 happy_var_1 [happy_var_1]+ )}++happyReduce_236 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_236 = happySpecReduce_2 88# happyReduction_236+happyReduction_236 happy_x_2+ happy_x_1+ = case happyOut104 happy_x_1 of { happy_var_1 -> + case happyOut105 happy_x_2 of { happy_var_2 -> + happyIn104+ (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1+ )}}++happyReduce_237 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_237 = happySpecReduce_1 89# happyReduction_237+happyReduction_237 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn105+ (sL1 happy_var_1 $ Just $ getVARID happy_var_1+ )}++happyReduce_238 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_238 = happySpecReduce_1 89# happyReduction_238+happyReduction_238 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn105+ (sL1 happy_var_1 Nothing+ )}++happyReduce_239 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_239 = happyMonadReduce 4# 90# happyReduction_239+happyReduction_239 (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 happyOut107 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut239 happy_x_4 of { happy_var_4 -> + ( let (name, args,as ) = happy_var_2 in+ ams (sLL happy_var_1 happy_var_4 . ValD $ mkPatSynBind name args happy_var_4+ ImplicitBidirectional)+ (as ++ [mj AnnPattern happy_var_1, mj AnnEqual happy_var_3]))}}}})+ ) (\r -> happyReturn (happyIn106 r))++happyReduce_240 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_240 = happyMonadReduce 4# 90# happyReduction_240+happyReduction_240 (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 happyOut107 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut239 happy_x_4 of { happy_var_4 -> + ( let (name, args, as) = happy_var_2 in+ ams (sLL happy_var_1 happy_var_4 . ValD $ mkPatSynBind name args happy_var_4 Unidirectional)+ (as ++ [mj AnnPattern happy_var_1,mu AnnLarrow happy_var_3]))}}}})+ ) (\r -> happyReturn (happyIn106 r))++happyReduce_241 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_241 = happyMonadReduce 5# 90# happyReduction_241+happyReduction_241 (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 happyOut107 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut239 happy_x_4 of { happy_var_4 -> + case happyOut110 happy_x_5 of { happy_var_5 -> + ( do { let (name, args, as) = happy_var_2+ ; mg <- mkPatSynMatchGroup name (snd $ unLoc happy_var_5)+ ; ams (sLL happy_var_1 happy_var_5 . ValD $+ mkPatSynBind name args happy_var_4 (ExplicitBidirectional mg))+ (as ++ ((mj AnnPattern happy_var_1:mu AnnLarrow happy_var_3:(fst $ unLoc happy_var_5))) )+ })}}}}})+ ) (\r -> happyReturn (happyIn106 r))++happyReduce_242 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_242 = happySpecReduce_2 91# happyReduction_242+happyReduction_242 happy_x_2+ happy_x_1+ = case happyOut265 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_2 of { happy_var_2 -> + happyIn107+ ((happy_var_1, PrefixCon happy_var_2, [])+ )}}++happyReduce_243 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_243 = happySpecReduce_3 91# happyReduction_243+happyReduction_243 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut294 happy_x_1 of { happy_var_1 -> + case happyOut269 happy_x_2 of { happy_var_2 -> + case happyOut294 happy_x_3 of { happy_var_3 -> + happyIn107+ ((happy_var_2, InfixCon happy_var_1 happy_var_3, [])+ )}}}++happyReduce_244 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_244 = happyReduce 4# 91# happyReduction_244+happyReduction_244 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut265 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn107+ ((happy_var_1, RecCon happy_var_3, [moc happy_var_2, mcc happy_var_4] )+ ) `HappyStk` happyRest}}}}++happyReduce_245 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_245 = happySpecReduce_0 92# happyReduction_245+happyReduction_245 = happyIn108+ ([]+ )++happyReduce_246 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_246 = happySpecReduce_2 92# happyReduction_246+happyReduction_246 happy_x_2+ happy_x_1+ = case happyOut294 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_2 of { happy_var_2 -> + happyIn108+ (happy_var_1 : happy_var_2+ )}}++happyReduce_247 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_247 = happySpecReduce_1 93# happyReduction_247+happyReduction_247 happy_x_1+ = case happyOut291 happy_x_1 of { happy_var_1 -> + happyIn109+ ([RecordPatSynField happy_var_1 happy_var_1]+ )}++happyReduce_248 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_248 = happyMonadReduce 3# 93# happyReduction_248+happyReduction_248 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut291 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + ( addAnnotation (getLoc happy_var_1) AnnComma (getLoc happy_var_2) >>+ return ((RecordPatSynField happy_var_1 happy_var_1) : happy_var_3 ))}}})+ ) (\r -> happyReturn (happyIn109 r))++happyReduce_249 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_249 = happyReduce 4# 94# happyReduction_249+happyReduction_249 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut120 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn110+ (sLL happy_var_1 happy_var_4 ((mj AnnWhere happy_var_1:moc happy_var_2+ :mcc happy_var_4:(fst $ unLoc happy_var_3)),sL1 happy_var_3 (snd $ unLoc happy_var_3))+ ) `HappyStk` happyRest}}}}++happyReduce_250 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_250 = happyReduce 4# 94# happyReduction_250+happyReduction_250 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut120 happy_x_3 of { happy_var_3 -> + happyIn110+ (L (comb2 happy_var_1 happy_var_3) ((mj AnnWhere happy_var_1:(fst $ unLoc happy_var_3))+ ,sL1 happy_var_3 (snd $ unLoc happy_var_3))+ ) `HappyStk` happyRest}}++happyReduce_251 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_251 = happyMonadReduce 4# 95# happyReduction_251+happyReduction_251 (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 happyOut266 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut145 happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $ PatSynSig (unLoc happy_var_2) (mkLHsSigType happy_var_4))+ [mj AnnPattern happy_var_1, mu AnnDcolon happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn111 r))++happyReduce_252 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_252 = happySpecReduce_1 96# happyReduction_252+happyReduction_252 happy_x_1+ = case happyOut90 happy_x_1 of { happy_var_1 -> + happyIn112+ (happy_var_1+ )}++happyReduce_253 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_253 = happySpecReduce_1 96# happyReduction_253+happyReduction_253 happy_x_1+ = case happyOut192 happy_x_1 of { happy_var_1 -> + happyIn112+ (happy_var_1+ )}++happyReduce_254 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_254 = happyMonadReduce 4# 96# happyReduction_254+happyReduction_254 (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 happyOut201 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut145 happy_x_4 of { happy_var_4 -> + ( do { v <- checkValSigLhs happy_var_2+ ; let err = text "in default signature" <> colon <+>+ quotes (ppr happy_var_2)+ ; ams (sLL happy_var_1 happy_var_4 $ SigD $ ClassOpSig True [v] $ mkLHsSigType happy_var_4)+ [mj AnnDefault happy_var_1,mu AnnDcolon happy_var_3] })}}}})+ ) (\r -> happyReturn (happyIn112 r))++happyReduce_255 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_255 = happyMonadReduce 3# 97# happyReduction_255+happyReduction_255 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut112 happy_x_3 of { happy_var_3 -> + ( if isNilOL (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ , unitOL happy_var_3))+ else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]+ >> return (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1+ ,(snd $ unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn113 r))++happyReduce_256 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_256 = happyMonadReduce 2# 97# happyReduction_256+happyReduction_256 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( if isNilOL (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ ,snd $ unLoc happy_var_1))+ else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]+ >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+ ) (\r -> happyReturn (happyIn113 r))++happyReduce_257 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_257 = happySpecReduce_1 97# happyReduction_257+happyReduction_257 happy_x_1+ = case happyOut112 happy_x_1 of { happy_var_1 -> + happyIn113+ (sL1 happy_var_1 ([], unitOL happy_var_1)+ )}++happyReduce_258 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_258 = happySpecReduce_0 97# happyReduction_258+happyReduction_258 = happyIn113+ (noLoc ([],nilOL)+ )++happyReduce_259 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_259 = happySpecReduce_3 98# happyReduction_259+happyReduction_259 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut113 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn114+ (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)+ ,snd $ unLoc happy_var_2)+ )}}}++happyReduce_260 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_260 = happySpecReduce_3 98# happyReduction_260+happyReduction_260 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut113 happy_x_2 of { happy_var_2 -> + happyIn114+ (happy_var_2+ )}++happyReduce_261 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_261 = happySpecReduce_2 99# happyReduction_261+happyReduction_261 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut114 happy_x_2 of { happy_var_2 -> + happyIn115+ (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)+ ,snd $ unLoc happy_var_2)+ )}}++happyReduce_262 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_262 = happySpecReduce_0 99# happyReduction_262+happyReduction_262 = happyIn115+ (noLoc ([],nilOL)+ )++happyReduce_263 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_263 = happySpecReduce_1 100# happyReduction_263+happyReduction_263 happy_x_1+ = case happyOut93 happy_x_1 of { happy_var_1 -> + happyIn116+ (sLL happy_var_1 happy_var_1 (unitOL (sL1 happy_var_1 (InstD (unLoc happy_var_1))))+ )}++happyReduce_264 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_264 = happySpecReduce_1 100# happyReduction_264+happyReduction_264 happy_x_1+ = case happyOut192 happy_x_1 of { happy_var_1 -> + happyIn116+ (sLL happy_var_1 happy_var_1 (unitOL happy_var_1)+ )}++happyReduce_265 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_265 = happyMonadReduce 3# 101# happyReduction_265+happyReduction_265 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut117 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut116 happy_x_3 of { happy_var_3 -> + ( if isNilOL (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ , unLoc happy_var_3))+ else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+ >> return+ (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1+ ,(snd $ unLoc happy_var_1) `appOL` unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn117 r))++happyReduce_266 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_266 = happyMonadReduce 2# 101# happyReduction_266+happyReduction_266 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut117 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( if isNilOL (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ ,snd $ unLoc happy_var_1))+ else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+ >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+ ) (\r -> happyReturn (happyIn117 r))++happyReduce_267 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_267 = happySpecReduce_1 101# happyReduction_267+happyReduction_267 happy_x_1+ = case happyOut116 happy_x_1 of { happy_var_1 -> + happyIn117+ (sL1 happy_var_1 ([],unLoc happy_var_1)+ )}++happyReduce_268 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_268 = happySpecReduce_0 101# happyReduction_268+happyReduction_268 = happyIn117+ (noLoc ([],nilOL)+ )++happyReduce_269 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_269 = happySpecReduce_3 102# happyReduction_269+happyReduction_269 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn118+ (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2),snd $ unLoc happy_var_2)+ )}}}++happyReduce_270 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_270 = happySpecReduce_3 102# happyReduction_270+happyReduction_270 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut117 happy_x_2 of { happy_var_2 -> + happyIn118+ (L (gl happy_var_2) (unLoc happy_var_2)+ )}++happyReduce_271 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_271 = happySpecReduce_2 103# happyReduction_271+happyReduction_271 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut118 happy_x_2 of { happy_var_2 -> + happyIn119+ (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)+ ,(snd $ unLoc happy_var_2))+ )}}++happyReduce_272 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_272 = happySpecReduce_0 103# happyReduction_272+happyReduction_272 = happyIn119+ (noLoc ([],nilOL)+ )++happyReduce_273 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_273 = happyMonadReduce 3# 104# happyReduction_273+happyReduction_273 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut120 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut192 happy_x_3 of { happy_var_3 -> + ( if isNilOL (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ , unitOL happy_var_3))+ else do ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+ >> return (+ let { this = unitOL happy_var_3;+ rest = snd $ unLoc happy_var_1;+ these = rest `appOL` this }+ in rest `seq` this `seq` these `seq`+ (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,these))))}}})+ ) (\r -> happyReturn (happyIn120 r))++happyReduce_274 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_274 = happyMonadReduce 2# 104# happyReduction_274+happyReduction_274 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut120 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( if isNilOL (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ ,snd $ unLoc happy_var_1)))+ else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+ >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+ ) (\r -> happyReturn (happyIn120 r))++happyReduce_275 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_275 = happySpecReduce_1 104# happyReduction_275+happyReduction_275 happy_x_1+ = case happyOut192 happy_x_1 of { happy_var_1 -> + happyIn120+ (sL1 happy_var_1 ([], unitOL happy_var_1)+ )}++happyReduce_276 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_276 = happySpecReduce_0 104# happyReduction_276+happyReduction_276 = happyIn120+ (noLoc ([],nilOL)+ )++happyReduce_277 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_277 = happySpecReduce_3 105# happyReduction_277+happyReduction_277 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut120 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn121+ (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)+ ,sL1 happy_var_2 $ snd $ unLoc happy_var_2)+ )}}}++happyReduce_278 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_278 = happySpecReduce_3 105# happyReduction_278+happyReduction_278 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut120 happy_x_2 of { happy_var_2 -> + happyIn121+ (L (gl happy_var_2) (fst $ unLoc happy_var_2,sL1 happy_var_2 $ snd $ unLoc happy_var_2)+ )}++happyReduce_279 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_279 = happyMonadReduce 1# 106# happyReduction_279+happyReduction_279 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut121 happy_x_1 of { happy_var_1 -> + ( do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc happy_var_1)+ ; return (sL1 happy_var_1 (fst $ unLoc happy_var_1+ ,sL1 happy_var_1 $ HsValBinds val_binds)) })})+ ) (\r -> happyReturn (happyIn122 r))++happyReduce_280 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_280 = happySpecReduce_3 106# happyReduction_280+happyReduction_280 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut251 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn122+ (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]+ ,sL1 happy_var_2 $ HsIPBinds (IPBinds (reverse $ unLoc happy_var_2)+ emptyTcEvBinds))+ )}}}++happyReduce_281 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_281 = happySpecReduce_3 106# happyReduction_281+happyReduction_281 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut251 happy_x_2 of { happy_var_2 -> + happyIn122+ (L (getLoc happy_var_2) ([]+ ,sL1 happy_var_2 $ HsIPBinds (IPBinds (reverse $ unLoc happy_var_2)+ emptyTcEvBinds))+ )}++happyReduce_282 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_282 = happySpecReduce_2 107# happyReduction_282+happyReduction_282 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut122 happy_x_2 of { happy_var_2 -> + happyIn123+ (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1 : (fst $ unLoc happy_var_2)+ ,snd $ unLoc happy_var_2)+ )}}++happyReduce_283 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_283 = happySpecReduce_0 107# happyReduction_283+happyReduction_283 = happyIn123+ (noLoc ([],noLoc emptyLocalBinds)+ )++happyReduce_284 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_284 = happyMonadReduce 3# 108# happyReduction_284+happyReduction_284 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+ >> return (happy_var_1 `snocOL` happy_var_3))}}})+ ) (\r -> happyReturn (happyIn124 r))++happyReduce_285 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_285 = happyMonadReduce 2# 108# happyReduction_285+happyReduction_285 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+ >> return happy_var_1)}})+ ) (\r -> happyReturn (happyIn124 r))++happyReduce_286 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_286 = happySpecReduce_1 108# happyReduction_286+happyReduction_286 happy_x_1+ = case happyOut125 happy_x_1 of { happy_var_1 -> + happyIn124+ (unitOL happy_var_1+ )}++happyReduce_287 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_287 = happySpecReduce_0 108# happyReduction_287+happyReduction_287 = happyIn124+ (nilOL+ )++happyReduce_288 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_288 = happyMonadReduce 6# 109# happyReduction_288+happyReduction_288 (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 happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut128 happy_x_3 of { happy_var_3 -> + case happyOut201 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + case happyOut200 happy_x_6 of { happy_var_6 -> + (ams (sLL happy_var_1 happy_var_6 $ (HsRule (L (gl happy_var_1) (getSTRINGs happy_var_1,getSTRING happy_var_1))+ ((snd happy_var_2) `orElse` AlwaysActive)+ (snd happy_var_3) happy_var_4 placeHolderNames happy_var_6+ placeHolderNames))+ (mj AnnEqual happy_var_5 : (fst happy_var_2) ++ (fst happy_var_3)))}}}}}})+ ) (\r -> happyReturn (happyIn125 r))++happyReduce_289 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_289 = happySpecReduce_0 110# happyReduction_289+happyReduction_289 = happyIn126+ (([],Nothing)+ )++happyReduce_290 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_290 = happySpecReduce_1 110# happyReduction_290+happyReduction_290 happy_x_1+ = case happyOut127 happy_x_1 of { happy_var_1 -> + happyIn126+ ((fst happy_var_1,Just (snd happy_var_1))+ )}++happyReduce_291 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_291 = happySpecReduce_3 111# happyReduction_291+happyReduction_291 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn127+ (([mos happy_var_1,mj AnnVal happy_var_2,mcs happy_var_3]+ ,ActiveAfter (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))+ )}}}++happyReduce_292 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_292 = happyReduce 4# 111# happyReduction_292+happyReduction_292 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn127+ (([mos happy_var_1,mj AnnTilde happy_var_2,mj AnnVal happy_var_3,mcs happy_var_4]+ ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))+ ) `HappyStk` happyRest}}}}++happyReduce_293 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_293 = happySpecReduce_3 111# happyReduction_293+happyReduction_293 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn127+ (([mos happy_var_1,mj AnnTilde happy_var_2,mcs happy_var_3]+ ,NeverActive)+ )}}}++happyReduce_294 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_294 = happySpecReduce_3 112# happyReduction_294+happyReduction_294 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut129 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn128+ (([mu AnnForall happy_var_1,mj AnnDot happy_var_3],happy_var_2)+ )}}}++happyReduce_295 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_295 = happySpecReduce_0 112# happyReduction_295+happyReduction_295 = happyIn128+ (([],[])+ )++happyReduce_296 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_296 = happySpecReduce_1 113# happyReduction_296+happyReduction_296 happy_x_1+ = case happyOut130 happy_x_1 of { happy_var_1 -> + happyIn129+ ([happy_var_1]+ )}++happyReduce_297 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_297 = happySpecReduce_2 113# happyReduction_297+happyReduction_297 happy_x_2+ happy_x_1+ = case happyOut130 happy_x_1 of { happy_var_1 -> + case happyOut129 happy_x_2 of { happy_var_2 -> + happyIn129+ (happy_var_1 : happy_var_2+ )}}++happyReduce_298 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_298 = happySpecReduce_1 114# happyReduction_298+happyReduction_298 happy_x_1+ = case happyOut294 happy_x_1 of { happy_var_1 -> + happyIn130+ (sLL happy_var_1 happy_var_1 (RuleBndr happy_var_1)+ )}++happyReduce_299 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_299 = happyMonadReduce 5# 114# happyReduction_299+happyReduction_299 (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 happyOut294 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut151 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( ams (sLL happy_var_1 happy_var_5 (RuleBndrSig happy_var_2+ (mkLHsSigWcType happy_var_4)))+ [mop happy_var_1,mu AnnDcolon happy_var_3,mcp happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn130 r))++happyReduce_300 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_300 = happyMonadReduce 3# 115# happyReduction_300+happyReduction_300 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut131 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut132 happy_x_3 of { happy_var_3 -> + ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+ >> return (happy_var_1 `appOL` happy_var_3))}}})+ ) (\r -> happyReturn (happyIn131 r))++happyReduce_301 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_301 = happyMonadReduce 2# 115# happyReduction_301+happyReduction_301 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut131 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+ >> return happy_var_1)}})+ ) (\r -> happyReturn (happyIn131 r))++happyReduce_302 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_302 = happySpecReduce_1 115# happyReduction_302+happyReduction_302 happy_x_1+ = case happyOut132 happy_x_1 of { happy_var_1 -> + happyIn131+ (happy_var_1+ )}++happyReduce_303 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_303 = happySpecReduce_0 115# happyReduction_303+happyReduction_303 = happyIn131+ (nilOL+ )++happyReduce_304 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_304 = happyMonadReduce 2# 116# happyReduction_304+happyReduction_304 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut260 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_2 of { happy_var_2 -> + ( amsu (sLL happy_var_1 happy_var_2 (Warning (unLoc happy_var_1) (WarningTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))+ (fst $ unLoc happy_var_2))}})+ ) (\r -> happyReturn (happyIn132 r))++happyReduce_305 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_305 = happyMonadReduce 3# 117# happyReduction_305+happyReduction_305 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut133 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut134 happy_x_3 of { happy_var_3 -> + ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+ >> return (happy_var_1 `appOL` happy_var_3))}}})+ ) (\r -> happyReturn (happyIn133 r))++happyReduce_306 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_306 = happyMonadReduce 2# 117# happyReduction_306+happyReduction_306 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut133 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+ >> return happy_var_1)}})+ ) (\r -> happyReturn (happyIn133 r))++happyReduce_307 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_307 = happySpecReduce_1 117# happyReduction_307+happyReduction_307 happy_x_1+ = case happyOut134 happy_x_1 of { happy_var_1 -> + happyIn133+ (happy_var_1+ )}++happyReduce_308 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_308 = happySpecReduce_0 117# happyReduction_308+happyReduction_308 = happyIn133+ (nilOL+ )++happyReduce_309 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_309 = happyMonadReduce 2# 118# happyReduction_309+happyReduction_309 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut260 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_2 of { happy_var_2 -> + ( amsu (sLL happy_var_1 happy_var_2 $ (Warning (unLoc happy_var_1) (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))+ (fst $ unLoc happy_var_2))}})+ ) (\r -> happyReturn (happyIn134 r))++happyReduce_310 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_310 = happySpecReduce_1 119# happyReduction_310+happyReduction_310 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn135+ (sL1 happy_var_1 ([],[L (gl happy_var_1) (getStringLiteral happy_var_1)])+ )}++happyReduce_311 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_311 = happySpecReduce_3 119# happyReduction_311+happyReduction_311 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut136 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn135+ (sLL happy_var_1 happy_var_3 $ ([mos happy_var_1,mcs happy_var_3],fromOL (unLoc happy_var_2))+ )}}}++happyReduce_312 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_312 = happyMonadReduce 3# 120# happyReduction_312+happyReduction_312 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut136 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 (unLoc happy_var_1 `snocOL`+ (L (gl happy_var_3) (getStringLiteral happy_var_3)))))}}})+ ) (\r -> happyReturn (happyIn136 r))++happyReduce_313 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_313 = happySpecReduce_1 120# happyReduction_313+happyReduction_313 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn136+ (sLL happy_var_1 happy_var_1 (unitOL (L (gl happy_var_1) (getStringLiteral happy_var_1)))+ )}++happyReduce_314 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_314 = happySpecReduce_0 120# happyReduction_314+happyReduction_314 = happyIn136+ (noLoc nilOL+ )++happyReduce_315 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_315 = happyMonadReduce 4# 121# happyReduction_315+happyReduction_315 (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 happyOut261 happy_x_2 of { happy_var_2 -> + case happyOut209 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 (AnnD $ HsAnnotation+ (getANN_PRAGs happy_var_1)+ (ValueAnnProvenance happy_var_2) happy_var_3))+ [mo happy_var_1,mc happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn137 r))++happyReduce_316 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_316 = happyMonadReduce 5# 121# happyReduction_316+happyReduction_316 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut278 happy_x_3 of { happy_var_3 -> + case happyOut209 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( ams (sLL happy_var_1 happy_var_5 (AnnD $ HsAnnotation+ (getANN_PRAGs happy_var_1)+ (TypeAnnProvenance happy_var_3) happy_var_4))+ [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn137 r))++happyReduce_317 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_317 = happyMonadReduce 4# 121# happyReduction_317+happyReduction_317 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut209 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 (AnnD $ HsAnnotation+ (getANN_PRAGs happy_var_1)+ ModuleAnnProvenance happy_var_3))+ [mo happy_var_1,mj AnnModule happy_var_2,mc happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn137 r))++happyReduce_318 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_318 = happyMonadReduce 4# 122# 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 { happy_var_1 -> + case happyOut139 happy_x_2 of { happy_var_2 -> + case happyOut140 happy_x_3 of { happy_var_3 -> + case happyOut141 happy_x_4 of { happy_var_4 -> + ( mkImport happy_var_2 happy_var_3 (snd $ unLoc happy_var_4) >>= \i ->+ return (sLL happy_var_1 happy_var_4 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_4),i)))}}}})+ ) (\r -> happyReturn (happyIn138 r))++happyReduce_319 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_319 = happyMonadReduce 3# 122# happyReduction_319+happyReduction_319 (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 happyOut139 happy_x_2 of { happy_var_2 -> + case happyOut141 happy_x_3 of { happy_var_3 -> + ( do { d <- mkImport happy_var_2 (noLoc PlaySafe) (snd $ unLoc happy_var_3);+ return (sLL happy_var_1 happy_var_3 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_3),d)) })}}})+ ) (\r -> happyReturn (happyIn138 r))++happyReduce_320 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_320 = happyMonadReduce 3# 122# happyReduction_320+happyReduction_320 (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 happyOut139 happy_x_2 of { happy_var_2 -> + case happyOut141 happy_x_3 of { happy_var_3 -> + ( mkExport happy_var_2 (snd $ unLoc happy_var_3) >>= \i ->+ return (sLL happy_var_1 happy_var_3 (mj AnnExport happy_var_1 : (fst $ unLoc happy_var_3),i) ))}}})+ ) (\r -> happyReturn (happyIn138 r))++happyReduce_321 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_321 = happySpecReduce_1 123# happyReduction_321+happyReduction_321 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn139+ (sLL happy_var_1 happy_var_1 StdCallConv+ )}++happyReduce_322 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_322 = happySpecReduce_1 123# happyReduction_322+happyReduction_322 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn139+ (sLL happy_var_1 happy_var_1 CCallConv+ )}++happyReduce_323 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_323 = happySpecReduce_1 123# happyReduction_323+happyReduction_323 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn139+ (sLL happy_var_1 happy_var_1 CApiConv+ )}++happyReduce_324 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_324 = happySpecReduce_1 123# happyReduction_324+happyReduction_324 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn139+ (sLL happy_var_1 happy_var_1 PrimCallConv+ )}++happyReduce_325 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_325 = happySpecReduce_1 123# happyReduction_325+happyReduction_325 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn139+ (sLL happy_var_1 happy_var_1 JavaScriptCallConv+ )}++happyReduce_326 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_326 = happySpecReduce_1 124# happyReduction_326+happyReduction_326 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn140+ (sLL happy_var_1 happy_var_1 PlayRisky+ )}++happyReduce_327 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_327 = happySpecReduce_1 124# happyReduction_327+happyReduction_327 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn140+ (sLL happy_var_1 happy_var_1 PlaySafe+ )}++happyReduce_328 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_328 = happySpecReduce_1 124# happyReduction_328+happyReduction_328 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn140+ (sLL happy_var_1 happy_var_1 PlayInterruptible+ )}++happyReduce_329 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_329 = happyReduce 4# 125# happyReduction_329+happyReduction_329 (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 happyOut291 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut145 happy_x_4 of { happy_var_4 -> + happyIn141+ (sLL happy_var_1 happy_var_4 ([mu AnnDcolon happy_var_3]+ ,(L (getLoc happy_var_1)+ (getStringLiteral happy_var_1), happy_var_2, mkLHsSigType happy_var_4))+ ) `HappyStk` happyRest}}}}++happyReduce_330 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_330 = happySpecReduce_3 125# happyReduction_330+happyReduction_330 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut291 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + happyIn141+ (sLL happy_var_1 happy_var_3 ([mu AnnDcolon happy_var_2]+ ,(noLoc (StringLiteral NoSourceText nilFS), happy_var_1, mkLHsSigType happy_var_3))+ )}}}++happyReduce_331 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_331 = happySpecReduce_0 126# happyReduction_331+happyReduction_331 = happyIn142+ (([],Nothing)+ )++happyReduce_332 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_332 = happySpecReduce_2 126# happyReduction_332+happyReduction_332 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut144 happy_x_2 of { happy_var_2 -> + happyIn142+ (([mu AnnDcolon happy_var_1],Just happy_var_2)+ )}}++happyReduce_333 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_333 = happySpecReduce_0 127# happyReduction_333+happyReduction_333 = happyIn143+ (([], Nothing)+ )++happyReduce_334 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_334 = happySpecReduce_2 127# happyReduction_334+happyReduction_334 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut271 happy_x_2 of { happy_var_2 -> + happyIn143+ (([mu AnnDcolon happy_var_1], Just happy_var_2)+ )}}++happyReduce_335 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_335 = happySpecReduce_1 128# happyReduction_335+happyReduction_335 happy_x_1+ = case happyOut151 happy_x_1 of { happy_var_1 -> + happyIn144+ (happy_var_1+ )}++happyReduce_336 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_336 = happySpecReduce_1 129# happyReduction_336+happyReduction_336 happy_x_1+ = case happyOut152 happy_x_1 of { happy_var_1 -> + happyIn145+ (happy_var_1+ )}++happyReduce_337 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_337 = happyMonadReduce 3# 130# happyReduction_337+happyReduction_337 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut146 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut291 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1)+ AnnComma (gl happy_var_2)+ >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+ ) (\r -> happyReturn (happyIn146 r))++happyReduce_338 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_338 = happySpecReduce_1 130# happyReduction_338+happyReduction_338 happy_x_1+ = case happyOut291 happy_x_1 of { happy_var_1 -> + happyIn146+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_339 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_339 = happySpecReduce_1 131# happyReduction_339+happyReduction_339 happy_x_1+ = case happyOut144 happy_x_1 of { happy_var_1 -> + happyIn147+ (unitOL (mkLHsSigType happy_var_1)+ )}++happyReduce_340 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_340 = happyMonadReduce 3# 131# happyReduction_340+happyReduction_340 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut144 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut147 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+ >> return (unitOL (mkLHsSigType happy_var_1) `appOL` happy_var_3))}}})+ ) (\r -> happyReturn (happyIn147 r))++happyReduce_341 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_341 = happySpecReduce_1 132# happyReduction_341+happyReduction_341 happy_x_1+ = case happyOut149 happy_x_1 of { happy_var_1 -> + happyIn148+ (sL1 happy_var_1 (let (a, str) = unLoc happy_var_1 in (a, HsSrcBang NoSourceText NoSrcUnpack str))+ )}++happyReduce_342 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_342 = happySpecReduce_1 132# happyReduction_342+happyReduction_342 happy_x_1+ = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn148+ (sL1 happy_var_1 (let (a, prag, unpk) = unLoc happy_var_1 in (a, HsSrcBang prag unpk NoSrcStrict))+ )}++happyReduce_343 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_343 = happySpecReduce_2 132# happyReduction_343+happyReduction_343 happy_x_2+ happy_x_1+ = case happyOut150 happy_x_1 of { happy_var_1 -> + case happyOut149 happy_x_2 of { happy_var_2 -> + happyIn148+ (sLL happy_var_1 happy_var_2 (let { (a, prag, unpk) = unLoc happy_var_1+ ; (a', str) = unLoc happy_var_2 }+ in (a ++ a', HsSrcBang prag unpk str))+ )}}++happyReduce_344 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_344 = happySpecReduce_1 133# happyReduction_344+happyReduction_344 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn149+ (sL1 happy_var_1 ([mj AnnBang happy_var_1], SrcStrict)+ )}++happyReduce_345 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_345 = happySpecReduce_1 133# happyReduction_345+happyReduction_345 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn149+ (sL1 happy_var_1 ([mj AnnTilde happy_var_1], SrcLazy)+ )}++happyReduce_346 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_346 = happySpecReduce_2 134# happyReduction_346+happyReduction_346 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn150+ (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getUNPACK_PRAGs happy_var_1, SrcUnpack)+ )}}++happyReduce_347 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_347 = happySpecReduce_2 134# happyReduction_347+happyReduction_347 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn150+ (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getNOUNPACK_PRAGs happy_var_1, SrcNoUnpack)+ )}}++happyReduce_348 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_348 = happyMonadReduce 4# 135# happyReduction_348+happyReduction_348 (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 happyOut167 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut151 happy_x_4 of { happy_var_4 -> + ( hintExplicitForall (getLoc happy_var_1) >>+ ams (sLL happy_var_1 happy_var_4 $+ HsForAllTy { hst_bndrs = happy_var_2+ , hst_body = happy_var_4 })+ [mu AnnForall happy_var_1, mj AnnDot happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn151 r))++happyReduce_349 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_349 = happyMonadReduce 3# 135# happyReduction_349+happyReduction_349 (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 { happy_var_2 -> + case happyOut151 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)+ >> return (sLL happy_var_1 happy_var_3 $+ HsQualTy { hst_ctxt = happy_var_1+ , hst_body = happy_var_3 }))}}})+ ) (\r -> happyReturn (happyIn151 r))++happyReduce_350 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_350 = happyMonadReduce 3# 135# happyReduction_350+happyReduction_350 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut253 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (HsIParamTy happy_var_1 happy_var_3))+ [mu AnnDcolon happy_var_2])}}})+ ) (\r -> happyReturn (happyIn151 r))++happyReduce_351 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_351 = happySpecReduce_1 135# happyReduction_351+happyReduction_351 happy_x_1+ = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn151+ (happy_var_1+ )}++happyReduce_352 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_352 = happyMonadReduce 4# 136# happyReduction_352+happyReduction_352 (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 happyOut167 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut152 happy_x_4 of { happy_var_4 -> + ( hintExplicitForall (getLoc happy_var_1) >>+ ams (sLL happy_var_1 happy_var_4 $+ HsForAllTy { hst_bndrs = happy_var_2+ , hst_body = happy_var_4 })+ [mu AnnForall happy_var_1,mj AnnDot happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn152 r))++happyReduce_353 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_353 = happyMonadReduce 3# 136# happyReduction_353+happyReduction_353 (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 { happy_var_2 -> + case happyOut152 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)+ >> return (sLL happy_var_1 happy_var_3 $+ HsQualTy { hst_ctxt = happy_var_1+ , hst_body = happy_var_3 }))}}})+ ) (\r -> happyReturn (happyIn152 r))++happyReduce_354 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_354 = happyMonadReduce 3# 136# happyReduction_354+happyReduction_354 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut253 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut155 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (HsIParamTy happy_var_1 happy_var_3))+ [mu AnnDcolon happy_var_2])}}})+ ) (\r -> happyReturn (happyIn152 r))++happyReduce_355 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_355 = happySpecReduce_1 136# happyReduction_355+happyReduction_355 happy_x_1+ = case happyOut156 happy_x_1 of { happy_var_1 -> + happyIn152+ (happy_var_1+ )}++happyReduce_356 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_356 = happyMonadReduce 1# 137# happyReduction_356+happyReduction_356 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> + ( do { (anns,ctx) <- checkContext happy_var_1+ ; if null (unLoc ctx)+ then addAnnotation (gl happy_var_1) AnnUnit (gl happy_var_1)+ else return ()+ ; ams ctx anns+ })})+ ) (\r -> happyReturn (happyIn153 r))++happyReduce_357 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_357 = happyMonadReduce 1# 138# happyReduction_357+happyReduction_357 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut158 happy_x_1 of { happy_var_1 -> + ( do { ty <- splitTilde happy_var_1+ ; (anns,ctx) <- checkContext ty+ ; if null (unLoc ctx)+ then addAnnotation (gl ty) AnnUnit (gl ty)+ else return ()+ ; ams ctx anns+ })})+ ) (\r -> happyReturn (happyIn154 r))++happyReduce_358 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_358 = happySpecReduce_1 139# happyReduction_358+happyReduction_358 happy_x_1+ = case happyOut157 happy_x_1 of { happy_var_1 -> + happyIn155+ (happy_var_1+ )}++happyReduce_359 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_359 = happyMonadReduce 3# 139# happyReduction_359+happyReduction_359 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut151 happy_x_3 of { happy_var_3 -> + ( ams happy_var_1 [mu AnnRarrow happy_var_2] -- See note [GADT decl discards annotations]+ >> ams (sLL happy_var_1 happy_var_3 $ HsFunTy happy_var_1 happy_var_3)+ [mu AnnRarrow happy_var_2])}}})+ ) (\r -> happyReturn (happyIn155 r))++happyReduce_360 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_360 = happySpecReduce_1 140# happyReduction_360+happyReduction_360 happy_x_1+ = case happyOut157 happy_x_1 of { happy_var_1 -> + happyIn156+ (happy_var_1+ )}++happyReduce_361 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_361 = happySpecReduce_2 140# happyReduction_361+happyReduction_361 happy_x_2+ happy_x_1+ = case happyOut157 happy_x_1 of { happy_var_1 -> + case happyOut313 happy_x_2 of { happy_var_2 -> + happyIn156+ (sLL happy_var_1 happy_var_2 $ HsDocTy happy_var_1 happy_var_2+ )}}++happyReduce_362 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_362 = happyMonadReduce 3# 140# happyReduction_362+happyReduction_362 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut152 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsFunTy happy_var_1 happy_var_3)+ [mu AnnRarrow happy_var_2])}}})+ ) (\r -> happyReturn (happyIn156 r))++happyReduce_363 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_363 = happyMonadReduce 4# 140# happyReduction_363+happyReduction_363 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut157 happy_x_1 of { happy_var_1 -> + case happyOut313 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut152 happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $+ HsFunTy (L (comb2 happy_var_1 happy_var_2) (HsDocTy happy_var_1 happy_var_2))+ happy_var_4)+ [mu AnnRarrow happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn156 r))++happyReduce_364 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_364 = happyMonadReduce 1# 141# happyReduction_364+happyReduction_364 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut159 happy_x_1 of { happy_var_1 -> + ( splitTildeApps (reverse (unLoc happy_var_1)) >>=+ \ts -> return $ sL1 happy_var_1 $ HsAppsTy ts)})+ ) (\r -> happyReturn (happyIn157 r))++happyReduce_365 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_365 = happySpecReduce_2 142# happyReduction_365+happyReduction_365 happy_x_2+ happy_x_1+ = case happyOut158 happy_x_1 of { happy_var_1 -> + case happyOut161 happy_x_2 of { happy_var_2 -> + happyIn158+ (sLL happy_var_1 happy_var_2 $ HsAppTy happy_var_1 happy_var_2+ )}}++happyReduce_366 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_366 = happySpecReduce_1 142# happyReduction_366+happyReduction_366 happy_x_1+ = case happyOut161 happy_x_1 of { happy_var_1 -> + happyIn158+ (happy_var_1+ )}++happyReduce_367 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_367 = happySpecReduce_1 143# happyReduction_367+happyReduction_367 happy_x_1+ = case happyOut160 happy_x_1 of { happy_var_1 -> + happyIn159+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_368 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_368 = happySpecReduce_2 143# happyReduction_368+happyReduction_368 happy_x_2+ happy_x_1+ = case happyOut159 happy_x_1 of { happy_var_1 -> + case happyOut160 happy_x_2 of { happy_var_2 -> + happyIn159+ (sLL happy_var_1 happy_var_2 $ happy_var_2 : (unLoc happy_var_1)+ )}}++happyReduce_369 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_369 = happySpecReduce_1 144# happyReduction_369+happyReduction_369 happy_x_1+ = case happyOut161 happy_x_1 of { happy_var_1 -> + happyIn160+ (sL1 happy_var_1 $ HsAppPrefix happy_var_1+ )}++happyReduce_370 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_370 = happySpecReduce_1 144# happyReduction_370+happyReduction_370 happy_x_1+ = case happyOut275 happy_x_1 of { happy_var_1 -> + happyIn160+ (sL1 happy_var_1 $ HsAppInfix happy_var_1+ )}++happyReduce_371 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_371 = happySpecReduce_1 144# happyReduction_371+happyReduction_371 happy_x_1+ = case happyOut289 happy_x_1 of { happy_var_1 -> + happyIn160+ (sL1 happy_var_1 $ HsAppInfix happy_var_1+ )}++happyReduce_372 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_372 = happyMonadReduce 2# 144# happyReduction_372+happyReduction_372 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut270 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsAppInfix happy_var_2)+ [mj AnnSimpleQuote happy_var_1])}})+ ) (\r -> happyReturn (happyIn160 r))++happyReduce_373 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_373 = happyMonadReduce 2# 144# happyReduction_373+happyReduction_373 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut282 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsAppInfix happy_var_2)+ [mj AnnSimpleQuote happy_var_1])}})+ ) (\r -> happyReturn (happyIn160 r))++happyReduce_374 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_374 = happySpecReduce_1 145# happyReduction_374+happyReduction_374 happy_x_1+ = case happyOut272 happy_x_1 of { happy_var_1 -> + happyIn161+ (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)+ )}++happyReduce_375 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_375 = happySpecReduce_1 145# happyReduction_375+happyReduction_375 happy_x_1+ = case happyOut288 happy_x_1 of { happy_var_1 -> + happyIn161+ (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)+ )}++happyReduce_376 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_376 = happyMonadReduce 2# 145# happyReduction_376+happyReduction_376 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut148 happy_x_1 of { happy_var_1 -> + case happyOut161 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 (HsBangTy (snd $ unLoc happy_var_1) happy_var_2))+ (fst $ unLoc happy_var_1))}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_377 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_377 = happyMonadReduce 3# 145# happyReduction_377+happyReduction_377 (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 happyOut183 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( amms (checkRecordSyntax+ (sLL happy_var_1 happy_var_3 $ HsRecTy happy_var_2))+ -- Constructor sigs only+ [moc happy_var_1,mcc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_378 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_378 = happyMonadReduce 2# 145# happyReduction_378+happyReduction_378 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy+ HsBoxedOrConstraintTuple [])+ [mop happy_var_1,mcp happy_var_2])}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_379 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_379 = happyMonadReduce 5# 145# happyReduction_379+happyReduction_379 (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 happyOut151 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut165 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( addAnnotation (gl happy_var_2) AnnComma+ (gl happy_var_3) >>+ ams (sLL happy_var_1 happy_var_5 $ HsTupleTy+ HsBoxedOrConstraintTuple (happy_var_2 : happy_var_4))+ [mop happy_var_1,mcp happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_380 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_380 = happyMonadReduce 2# 145# happyReduction_380+happyReduction_380 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy HsUnboxedTuple [])+ [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_381 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_381 = happyMonadReduce 3# 145# happyReduction_381+happyReduction_381 (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 happyOut165 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsTupleTy HsUnboxedTuple happy_var_2)+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_382 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_382 = happyMonadReduce 3# 145# happyReduction_382+happyReduction_382 (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 happyOut166 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsSumTy happy_var_2)+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_383 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_383 = happyMonadReduce 3# 145# happyReduction_383+happyReduction_383 (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 happyOut151 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsListTy happy_var_2) [mos happy_var_1,mcs happy_var_3])}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_384 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_384 = happyMonadReduce 3# 145# happyReduction_384+happyReduction_384 (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 happyOut151 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsPArrTy happy_var_2) [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_385 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_385 = happyMonadReduce 3# 145# 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 { happy_var_1 -> + case happyOut151 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsParTy happy_var_2) [mop happy_var_1,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_386 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_386 = happyMonadReduce 5# 145# happyReduction_386+happyReduction_386 (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 happyOut151 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut173 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( ams (sLL happy_var_1 happy_var_5 $ HsKindSig happy_var_2 happy_var_4)+ [mop happy_var_1,mu AnnDcolon happy_var_3,mcp happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_387 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_387 = happySpecReduce_1 145# happyReduction_387+happyReduction_387 happy_x_1+ = case happyOut199 happy_x_1 of { happy_var_1 -> + happyIn161+ (sL1 happy_var_1 (HsSpliceTy (unLoc happy_var_1) placeHolderKind)+ )}++happyReduce_388 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_388 = happyMonadReduce 3# 145# happyReduction_388+happyReduction_388 (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 happyOut200 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ mkHsSpliceTy HasParens happy_var_2)+ [mj AnnOpenPE happy_var_1,mj AnnCloseP happy_var_3])}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_389 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_389 = happyMonadReduce 1# 145# happyReduction_389+happyReduction_389 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + (ams (sLL happy_var_1 happy_var_1 $ mkHsSpliceTy HasDollar $ sL1 happy_var_1 $ HsVar $+ (sL1 happy_var_1 (mkUnqual varName (getTH_ID_SPLICE happy_var_1))))+ [mj AnnThIdSplice happy_var_1])})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_390 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_390 = happyMonadReduce 2# 145# happyReduction_390+happyReduction_390 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut262 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsTyVar Promoted happy_var_2) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_391 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_391 = happyMonadReduce 6# 145# happyReduction_391+happyReduction_391 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut151 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut165 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + ( addAnnotation (gl happy_var_3) AnnComma (gl happy_var_4) >>+ ams (sLL happy_var_1 happy_var_6 $ HsExplicitTupleTy [] (happy_var_3 : happy_var_5))+ [mj AnnSimpleQuote happy_var_1,mop happy_var_2,mcp happy_var_6])}}}}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_392 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_392 = happyMonadReduce 4# 145# happyReduction_392+happyReduction_392 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut164 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $ HsExplicitListTy Promoted+ placeHolderKind happy_var_3)+ [mj AnnSimpleQuote happy_var_1,mos happy_var_2,mcs happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_393 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_393 = happyMonadReduce 2# 145# happyReduction_393+happyReduction_393 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut291 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsTyVar Promoted happy_var_2)+ [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_394 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_394 = happyMonadReduce 5# 145# happyReduction_394+happyReduction_394 (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 happyOut151 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut165 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( addAnnotation (gl happy_var_2) AnnComma+ (gl happy_var_3) >>+ ams (sLL happy_var_1 happy_var_5 $ HsExplicitListTy NotPromoted+ placeHolderKind (happy_var_2 : happy_var_4))+ [mos happy_var_1,mcs happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn161 r))++happyReduce_395 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_395 = happySpecReduce_1 145# happyReduction_395+happyReduction_395 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn161+ (sLL happy_var_1 happy_var_1 $ HsTyLit $ HsNumTy (getINTEGERs happy_var_1)+ (il_value (getINTEGER happy_var_1))+ )}++happyReduce_396 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_396 = happySpecReduce_1 145# happyReduction_396+happyReduction_396 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn161+ (sLL happy_var_1 happy_var_1 $ HsTyLit $ HsStrTy (getSTRINGs happy_var_1)+ (getSTRING happy_var_1)+ )}++happyReduce_397 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_397 = happySpecReduce_1 145# happyReduction_397+happyReduction_397 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn161+ (sL1 happy_var_1 $ mkAnonWildCardTy+ )}++happyReduce_398 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_398 = happySpecReduce_1 146# happyReduction_398+happyReduction_398 happy_x_1+ = case happyOut144 happy_x_1 of { happy_var_1 -> + happyIn162+ (mkLHsSigType happy_var_1+ )}++happyReduce_399 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_399 = happySpecReduce_1 147# happyReduction_399+happyReduction_399 happy_x_1+ = case happyOut156 happy_x_1 of { happy_var_1 -> + happyIn163+ ([mkLHsSigType happy_var_1]+ )}++happyReduce_400 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_400 = happyMonadReduce 3# 147# happyReduction_400+happyReduction_400 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut156 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut163 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+ >> return (mkLHsSigType happy_var_1 : happy_var_3))}}})+ ) (\r -> happyReturn (happyIn163 r))++happyReduce_401 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_401 = happySpecReduce_1 148# happyReduction_401+happyReduction_401 happy_x_1+ = case happyOut165 happy_x_1 of { happy_var_1 -> + happyIn164+ (happy_var_1+ )}++happyReduce_402 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_402 = happySpecReduce_0 148# happyReduction_402+happyReduction_402 = happyIn164+ ([]+ )++happyReduce_403 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_403 = happySpecReduce_1 149# happyReduction_403+happyReduction_403 happy_x_1+ = case happyOut151 happy_x_1 of { happy_var_1 -> + happyIn165+ ([happy_var_1]+ )}++happyReduce_404 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_404 = happyMonadReduce 3# 149# happyReduction_404+happyReduction_404 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut151 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut165 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+ >> return (happy_var_1 : happy_var_3))}}})+ ) (\r -> happyReturn (happyIn165 r))++happyReduce_405 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_405 = happyMonadReduce 3# 150# happyReduction_405+happyReduction_405 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut151 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut151 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)+ >> return [happy_var_1,happy_var_3])}}})+ ) (\r -> happyReturn (happyIn166 r))++happyReduce_406 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_406 = happyMonadReduce 3# 150# happyReduction_406+happyReduction_406 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut151 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut166 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)+ >> return (happy_var_1 : happy_var_3))}}})+ ) (\r -> happyReturn (happyIn166 r))++happyReduce_407 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_407 = happySpecReduce_2 151# happyReduction_407+happyReduction_407 happy_x_2+ happy_x_1+ = case happyOut168 happy_x_1 of { happy_var_1 -> + case happyOut167 happy_x_2 of { happy_var_2 -> + happyIn167+ (happy_var_1 : happy_var_2+ )}}++happyReduce_408 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_408 = happySpecReduce_0 151# happyReduction_408+happyReduction_408 = happyIn167+ ([]+ )++happyReduce_409 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_409 = happySpecReduce_1 152# happyReduction_409+happyReduction_409 happy_x_1+ = case happyOut288 happy_x_1 of { happy_var_1 -> + happyIn168+ (sL1 happy_var_1 (UserTyVar happy_var_1)+ )}++happyReduce_410 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_410 = happyMonadReduce 5# 152# happyReduction_410+happyReduction_410 (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 happyOut288 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut173 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( ams (sLL happy_var_1 happy_var_5 (KindedTyVar happy_var_2 happy_var_4))+ [mop happy_var_1,mu AnnDcolon happy_var_3+ ,mcp happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn168 r))++happyReduce_411 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_411 = happySpecReduce_0 153# happyReduction_411+happyReduction_411 = happyIn169+ (noLoc ([],[])+ )++happyReduce_412 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_412 = happySpecReduce_2 153# happyReduction_412+happyReduction_412 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut170 happy_x_2 of { happy_var_2 -> + happyIn169+ ((sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]+ ,reverse (unLoc happy_var_2)))+ )}}++happyReduce_413 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_413 = happyMonadReduce 3# 154# happyReduction_413+happyReduction_413 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut170 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut171 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2)+ >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+ ) (\r -> happyReturn (happyIn170 r))++happyReduce_414 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_414 = happySpecReduce_1 154# happyReduction_414+happyReduction_414 happy_x_1+ = case happyOut171 happy_x_1 of { happy_var_1 -> + happyIn170+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_415 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_415 = happyMonadReduce 3# 155# happyReduction_415+happyReduction_415 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut172 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut172 happy_x_3 of { happy_var_3 -> + ( ams (L (comb3 happy_var_1 happy_var_2 happy_var_3)+ (reverse (unLoc happy_var_1), reverse (unLoc happy_var_3)))+ [mu AnnRarrow happy_var_2])}}})+ ) (\r -> happyReturn (happyIn171 r))++happyReduce_416 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_416 = happySpecReduce_0 156# happyReduction_416+happyReduction_416 = happyIn172+ (noLoc []+ )++happyReduce_417 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_417 = happySpecReduce_2 156# happyReduction_417+happyReduction_417 happy_x_2+ happy_x_1+ = case happyOut172 happy_x_1 of { happy_var_1 -> + case happyOut288 happy_x_2 of { happy_var_2 -> + happyIn172+ (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)+ )}}++happyReduce_418 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_418 = happySpecReduce_1 157# happyReduction_418+happyReduction_418 happy_x_1+ = case happyOut151 happy_x_1 of { happy_var_1 -> + happyIn173+ (happy_var_1+ )}++happyReduce_419 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_419 = happyReduce 4# 158# happyReduction_419+happyReduction_419 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut175 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn174+ (L (comb2 happy_var_1 happy_var_3)+ ([mj AnnWhere happy_var_1+ ,moc happy_var_2+ ,mcc happy_var_4]+ , unLoc happy_var_3)+ ) `HappyStk` happyRest}}}}++happyReduce_420 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_420 = happyReduce 4# 158# happyReduction_420+happyReduction_420 (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 happyOut175 happy_x_3 of { happy_var_3 -> + happyIn174+ (L (comb2 happy_var_1 happy_var_3)+ ([mj AnnWhere happy_var_1]+ , unLoc happy_var_3)+ ) `HappyStk` happyRest}}++happyReduce_421 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_421 = happySpecReduce_0 158# happyReduction_421+happyReduction_421 = happyIn174+ (noLoc ([],[])+ )++happyReduce_422 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_422 = happyMonadReduce 3# 159# happyReduction_422+happyReduction_422 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut176 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut175 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)+ >> return (L (comb2 happy_var_1 happy_var_3) (happy_var_1 : unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn175 r))++happyReduce_423 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_423 = happySpecReduce_1 159# happyReduction_423+happyReduction_423 happy_x_1+ = case happyOut176 happy_x_1 of { happy_var_1 -> + happyIn175+ (L (gl happy_var_1) [happy_var_1]+ )}++happyReduce_424 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_424 = happySpecReduce_0 159# happyReduction_424+happyReduction_424 = happyIn175+ (noLoc []+ )++happyReduce_425 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_425 = happyMonadReduce 3# 160# happyReduction_425+happyReduction_425 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut318 happy_x_1 of { happy_var_1 -> + case happyOut177 happy_x_3 of { happy_var_3 -> + ( return $ addConDoc happy_var_3 happy_var_1)}})+ ) (\r -> happyReturn (happyIn176 r))++happyReduce_426 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_426 = happyMonadReduce 1# 160# happyReduction_426+happyReduction_426 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut177 happy_x_1 of { happy_var_1 -> + ( return happy_var_1)})+ ) (\r -> happyReturn (happyIn176 r))++happyReduce_427 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_427 = happyMonadReduce 3# 161# happyReduction_427+happyReduction_427 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut266 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut144 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (mkGadtDecl (unLoc happy_var_1) (mkLHsSigType happy_var_3)))+ [mu AnnDcolon happy_var_2])}}})+ ) (\r -> happyReturn (happyIn177 r))++happyReduce_428 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_428 = happySpecReduce_3 162# happyReduction_428+happyReduction_428 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut318 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut179 happy_x_3 of { happy_var_3 -> + happyIn178+ (L (comb2 happy_var_2 happy_var_3) ([mj AnnEqual happy_var_2]+ ,addConDocs (unLoc happy_var_3) happy_var_1)+ )}}}++happyReduce_429 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_429 = happyMonadReduce 5# 163# happyReduction_429+happyReduction_429 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut179 happy_x_1 of { happy_var_1 -> + case happyOut318 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut317 happy_x_4 of { happy_var_4 -> + case happyOut180 happy_x_5 of { happy_var_5 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_3)+ >> return (sLL happy_var_1 happy_var_5 (addConDoc happy_var_5 happy_var_2 : addConDocFirst (unLoc happy_var_1) happy_var_4)))}}}}})+ ) (\r -> happyReturn (happyIn179 r))++happyReduce_430 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_430 = happySpecReduce_1 163# happyReduction_430+happyReduction_430 happy_x_1+ = case happyOut180 happy_x_1 of { happy_var_1 -> + happyIn179+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_431 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_431 = happyMonadReduce 6# 164# happyReduction_431+happyReduction_431 (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 happyOut318 happy_x_1 of { happy_var_1 -> + case happyOut181 happy_x_2 of { happy_var_2 -> + case happyOut154 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut182 happy_x_5 of { happy_var_5 -> + case happyOut317 happy_x_6 of { happy_var_6 -> + ( ams (let (con,details) = unLoc happy_var_5 in+ addConDoc (L (comb4 happy_var_2 happy_var_3 happy_var_4 happy_var_5) (mkConDeclH98 con+ (snd $ unLoc happy_var_2) happy_var_3 details))+ (happy_var_1 `mplus` happy_var_6))+ (mu AnnDarrow happy_var_4:(fst $ unLoc happy_var_2)))}}}}}})+ ) (\r -> happyReturn (happyIn180 r))++happyReduce_432 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_432 = happyMonadReduce 4# 164# happyReduction_432+happyReduction_432 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut318 happy_x_1 of { happy_var_1 -> + case happyOut181 happy_x_2 of { happy_var_2 -> + case happyOut182 happy_x_3 of { happy_var_3 -> + case happyOut317 happy_x_4 of { happy_var_4 -> + ( ams ( let (con,details) = unLoc happy_var_3 in+ addConDoc (L (comb2 happy_var_2 happy_var_3) (mkConDeclH98 con+ (snd $ unLoc happy_var_2) (noLoc []) details))+ (happy_var_1 `mplus` happy_var_4))+ (fst $ unLoc happy_var_2))}}}})+ ) (\r -> happyReturn (happyIn180 r))++happyReduce_433 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_433 = happySpecReduce_3 165# happyReduction_433+happyReduction_433 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut167 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn181+ (sLL happy_var_1 happy_var_3 ([mu AnnForall happy_var_1,mj AnnDot happy_var_3], Just happy_var_2)+ )}}}++happyReduce_434 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_434 = happySpecReduce_0 165# happyReduction_434+happyReduction_434 = happyIn181+ (noLoc ([], Nothing)+ )++happyReduce_435 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_435 = happyMonadReduce 1# 166# happyReduction_435+happyReduction_435 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut158 happy_x_1 of { happy_var_1 -> + ( do { c <- splitCon happy_var_1+ ; return $ sLL happy_var_1 happy_var_1 c })})+ ) (\r -> happyReturn (happyIn182 r))++happyReduce_436 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_436 = happyMonadReduce 3# 166# happyReduction_436+happyReduction_436 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut158 happy_x_1 of { happy_var_1 -> + case happyOut269 happy_x_2 of { happy_var_2 -> + case happyOut158 happy_x_3 of { happy_var_3 -> + ( do { ty <- splitTilde happy_var_1+ ; return $ sLL happy_var_1 happy_var_3 (happy_var_2, InfixCon ty happy_var_3) })}}})+ ) (\r -> happyReturn (happyIn182 r))++happyReduce_437 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_437 = happySpecReduce_0 167# happyReduction_437+happyReduction_437 = happyIn183+ ([]+ )++happyReduce_438 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_438 = happySpecReduce_1 167# happyReduction_438+happyReduction_438 happy_x_1+ = case happyOut184 happy_x_1 of { happy_var_1 -> + happyIn183+ (happy_var_1+ )}++happyReduce_439 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_439 = happyMonadReduce 5# 168# happyReduction_439+happyReduction_439 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut185 happy_x_1 of { happy_var_1 -> + case happyOut318 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut317 happy_x_4 of { happy_var_4 -> + case happyOut184 happy_x_5 of { happy_var_5 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_3) >>+ return ((addFieldDoc happy_var_1 happy_var_4) : addFieldDocs happy_var_5 happy_var_2))}}}}})+ ) (\r -> happyReturn (happyIn184 r))++happyReduce_440 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_440 = happySpecReduce_1 168# happyReduction_440+happyReduction_440 happy_x_1+ = case happyOut185 happy_x_1 of { happy_var_1 -> + happyIn184+ ([happy_var_1]+ )}++happyReduce_441 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_441 = happyMonadReduce 5# 169# happyReduction_441+happyReduction_441 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut318 happy_x_1 of { happy_var_1 -> + case happyOut146 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut151 happy_x_4 of { happy_var_4 -> + case happyOut317 happy_x_5 of { happy_var_5 -> + ( ams (L (comb2 happy_var_2 happy_var_4)+ (ConDeclField (reverse (map (\ln@(L l n) -> L l $ FieldOcc ln PlaceHolder) (unLoc happy_var_2))) happy_var_4 (happy_var_1 `mplus` happy_var_5)))+ [mu AnnDcolon happy_var_3])}}}}})+ ) (\r -> happyReturn (happyIn185 r))++happyReduce_442 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_442 = happySpecReduce_0 170# happyReduction_442+happyReduction_442 = happyIn186+ (noLoc []+ )++happyReduce_443 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_443 = happySpecReduce_1 170# happyReduction_443+happyReduction_443 happy_x_1+ = case happyOut187 happy_x_1 of { happy_var_1 -> + happyIn186+ (happy_var_1+ )}++happyReduce_444 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_444 = happySpecReduce_2 171# happyReduction_444+happyReduction_444 happy_x_2+ happy_x_1+ = case happyOut187 happy_x_1 of { happy_var_1 -> + case happyOut188 happy_x_2 of { happy_var_2 -> + happyIn187+ (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1+ )}}++happyReduce_445 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_445 = happySpecReduce_1 171# happyReduction_445+happyReduction_445 happy_x_1+ = case happyOut188 happy_x_1 of { happy_var_1 -> + happyIn187+ (sLL happy_var_1 happy_var_1 [happy_var_1]+ )}++happyReduce_446 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_446 = happyMonadReduce 3# 172# happyReduction_446+happyReduction_446 (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 happyOut82 happy_x_2 of { happy_var_2 -> + case happyOut277 happy_x_3 of { happy_var_3 -> + ( let { full_loc = comb2 happy_var_1 happy_var_3 }+ in ams (L full_loc $ HsDerivingClause happy_var_2 $ L full_loc+ [mkLHsSigType happy_var_3])+ [mj AnnDeriving happy_var_1])}}})+ ) (\r -> happyReturn (happyIn188 r))++happyReduce_447 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_447 = happyMonadReduce 4# 172# happyReduction_447+happyReduction_447 (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 happyOut82 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( let { full_loc = comb2 happy_var_1 happy_var_4 }+ in ams (L full_loc $ HsDerivingClause happy_var_2 $ L full_loc [])+ [mj AnnDeriving happy_var_1,mop happy_var_3,mcp happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn188 r))++happyReduce_448 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_448 = happyMonadReduce 5# 172# happyReduction_448+happyReduction_448 (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 happyOut82 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut163 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + ( let { full_loc = comb2 happy_var_1 happy_var_5 }+ in ams (L full_loc $ HsDerivingClause happy_var_2 $ L full_loc happy_var_4)+ [mj AnnDeriving happy_var_1,mop happy_var_3,mcp happy_var_5])}}}}})+ ) (\r -> happyReturn (happyIn188 r))++happyReduce_449 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_449 = happySpecReduce_1 173# happyReduction_449+happyReduction_449 happy_x_1+ = case happyOut190 happy_x_1 of { happy_var_1 -> + happyIn189+ (sL1 happy_var_1 (DocD (unLoc happy_var_1))+ )}++happyReduce_450 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_450 = happySpecReduce_1 174# happyReduction_450+happyReduction_450 happy_x_1+ = case happyOut312 happy_x_1 of { happy_var_1 -> + happyIn190+ (sL1 happy_var_1 (DocCommentNext (unLoc happy_var_1))+ )}++happyReduce_451 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_451 = happySpecReduce_1 174# happyReduction_451+happyReduction_451 happy_x_1+ = case happyOut313 happy_x_1 of { happy_var_1 -> + happyIn190+ (sL1 happy_var_1 (DocCommentPrev (unLoc happy_var_1))+ )}++happyReduce_452 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_452 = happySpecReduce_1 174# happyReduction_452+happyReduction_452 happy_x_1+ = case happyOut314 happy_x_1 of { happy_var_1 -> + happyIn190+ (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocCommentNamed n doc)+ )}++happyReduce_453 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_453 = happySpecReduce_1 174# happyReduction_453+happyReduction_453 happy_x_1+ = case happyOut315 happy_x_1 of { happy_var_1 -> + happyIn190+ (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocGroup n doc)+ )}++happyReduce_454 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_454 = happySpecReduce_1 175# happyReduction_454+happyReduction_454 happy_x_1+ = case happyOut196 happy_x_1 of { happy_var_1 -> + happyIn191+ (happy_var_1+ )}++happyReduce_455 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_455 = happyMonadReduce 3# 175# happyReduction_455+happyReduction_455 (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 happyOut209 happy_x_2 of { happy_var_2 -> + case happyOut193 happy_x_3 of { happy_var_3 -> + ( do { let { e = sLL happy_var_1 happy_var_2 (SectionR (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)+ -- Turn it all into an expression so that+ -- checkPattern can check that bangs are enabled+ ; l = comb2 happy_var_1 happy_var_3 };+ (ann, r) <- checkValDef empty SrcStrict e Nothing happy_var_3 ;+ -- Depending upon what the pattern looks like we might get either+ -- a FunBind or PatBind back from checkValDef. See Note+ -- [FunBind vs PatBind]+ case r of {+ (FunBind n _ _ _ _) ->+ ams (L l ()) [mj AnnFunId n] >> return () ;+ (PatBind (L lh _lhs) _rhs _ _ _) ->+ ams (L lh ()) [] >> return () } ;++ _ <- ams (L l ()) (ann ++ fst (unLoc happy_var_3) ++ [mj AnnBang happy_var_1]) ;+ return $! (sL l $ ValD r) })}}})+ ) (\r -> happyReturn (happyIn191 r))++happyReduce_456 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_456 = happyMonadReduce 3# 175# happyReduction_456+happyReduction_456 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut202 happy_x_1 of { happy_var_1 -> + case happyOut142 happy_x_2 of { happy_var_2 -> + case happyOut193 happy_x_3 of { happy_var_3 -> + ( do { (ann,r) <- checkValDef empty NoSrcStrict happy_var_1 (snd happy_var_2) happy_var_3;+ let { l = comb2 happy_var_1 happy_var_3 };+ -- Depending upon what the pattern looks like we might get either+ -- a FunBind or PatBind back from checkValDef. See Note+ -- [FunBind vs PatBind]+ case r of {+ (FunBind n _ _ _ _) ->+ ams (L l ()) (mj AnnFunId n:(fst happy_var_2)) >> return () ;+ (PatBind (L lh _lhs) _rhs _ _ _) ->+ ams (L lh ()) (fst happy_var_2) >> return () } ;+ _ <- ams (L l ()) (ann ++ (fst $ unLoc happy_var_3));+ return $! (sL l $ ValD r) })}}})+ ) (\r -> happyReturn (happyIn191 r))++happyReduce_457 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_457 = happySpecReduce_1 175# happyReduction_457+happyReduction_457 happy_x_1+ = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn191+ (happy_var_1+ )}++happyReduce_458 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_458 = happySpecReduce_1 175# happyReduction_458+happyReduction_458 happy_x_1+ = case happyOut189 happy_x_1 of { happy_var_1 -> + happyIn191+ (happy_var_1+ )}++happyReduce_459 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_459 = happySpecReduce_1 176# happyReduction_459+happyReduction_459 happy_x_1+ = case happyOut191 happy_x_1 of { happy_var_1 -> + happyIn192+ (happy_var_1+ )}++happyReduce_460 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_460 = happySpecReduce_1 176# happyReduction_460+happyReduction_460 happy_x_1+ = case happyOut212 happy_x_1 of { happy_var_1 -> + happyIn192+ (sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1+ )}++happyReduce_461 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_461 = happySpecReduce_3 177# happyReduction_461+happyReduction_461 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut200 happy_x_2 of { happy_var_2 -> + case happyOut123 happy_x_3 of { happy_var_3 -> + happyIn193+ (sL (comb3 happy_var_1 happy_var_2 happy_var_3)+ ((mj AnnEqual happy_var_1 : (fst $ unLoc happy_var_3))+ ,GRHSs (unguardedRHS (comb3 happy_var_1 happy_var_2 happy_var_3) happy_var_2)+ (snd $ unLoc happy_var_3))+ )}}}++happyReduce_462 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_462 = happySpecReduce_2 177# happyReduction_462+happyReduction_462 happy_x_2+ happy_x_1+ = case happyOut194 happy_x_1 of { happy_var_1 -> + case happyOut123 happy_x_2 of { happy_var_2 -> + happyIn193+ (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_2+ ,GRHSs (reverse (unLoc happy_var_1))+ (snd $ unLoc happy_var_2))+ )}}++happyReduce_463 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_463 = happySpecReduce_2 178# happyReduction_463+happyReduction_463 happy_x_2+ happy_x_1+ = case happyOut194 happy_x_1 of { happy_var_1 -> + case happyOut195 happy_x_2 of { happy_var_2 -> + happyIn194+ (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)+ )}}++happyReduce_464 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_464 = happySpecReduce_1 178# happyReduction_464+happyReduction_464 happy_x_1+ = case happyOut195 happy_x_1 of { happy_var_1 -> + happyIn194+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_465 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_465 = happyMonadReduce 4# 179# happyReduction_465+happyReduction_465 (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 happyOut228 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + ( ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS (unLoc happy_var_2) happy_var_4)+ [mj AnnVbar happy_var_1,mj AnnEqual happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn195 r))++happyReduce_466 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_466 = happyMonadReduce 3# 180# happyReduction_466+happyReduction_466 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut202 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + ( do v <- checkValSigLhs happy_var_1+ ; _ <- ams (sLL happy_var_1 happy_var_3 ()) [mu AnnDcolon happy_var_2]+ ; return (sLL happy_var_1 happy_var_3 $ SigD $+ TypeSig [v] (mkLHsSigWcType happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_467 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_467 = happyMonadReduce 5# 180# 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) tk+ = happyThen ((case happyOut291 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut146 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut145 happy_x_5 of { happy_var_5 -> + ( do { let sig = TypeSig (happy_var_1 : reverse (unLoc happy_var_3))+ (mkLHsSigWcType happy_var_5)+ ; addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+ ; ams ( sLL happy_var_1 happy_var_5 $ SigD sig )+ [mu AnnDcolon happy_var_4] })}}}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_468 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_468 = happyMonadReduce 3# 180# happyReduction_468+happyReduction_468 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut73 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut74 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ SigD+ (FixSig (FixitySig (fromOL $ unLoc happy_var_3)+ (Fixity (fst $ unLoc happy_var_2) (snd $ unLoc happy_var_2) (unLoc happy_var_1)))))+ [mj AnnInfix happy_var_1,mj AnnVal happy_var_2])}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_469 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_469 = happySpecReduce_1 180# happyReduction_469+happyReduction_469 happy_x_1+ = case happyOut111 happy_x_1 of { happy_var_1 -> + happyIn196+ (sLL happy_var_1 happy_var_1 . SigD . unLoc $ happy_var_1+ )}++happyReduce_470 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_470 = happyMonadReduce 4# 180# happyReduction_470+happyReduction_470 (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 happyOut266 happy_x_2 of { happy_var_2 -> + case happyOut143 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( let (dcolon, tc) = happy_var_3+ in ams+ (sLL happy_var_1 happy_var_4+ (SigD (CompleteMatchSig (getCOMPLETE_PRAGs happy_var_1) happy_var_2 tc)))+ ([ mo happy_var_1 ] ++ dcolon ++ [mc happy_var_4]))}}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_471 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_471 = happyMonadReduce 4# 180# happyReduction_471+happyReduction_471 (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 happyOut197 happy_x_2 of { happy_var_2 -> + case happyOut292 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams ((sLL happy_var_1 happy_var_4 $ SigD (InlineSig happy_var_3+ (mkInlinePragma (getINLINE_PRAGs happy_var_1) (getINLINE happy_var_1)+ (snd happy_var_2)))))+ ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_4]))}}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_472 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_472 = happyMonadReduce 3# 180# happyReduction_472+happyReduction_472 (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 happyOut292 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (SigD (SCCFunSig (getSCC_PRAGs happy_var_1) happy_var_2 Nothing)))+ [mo happy_var_1, mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_473 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_473 = happyMonadReduce 4# 180# happyReduction_473+happyReduction_473 (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 happyOut292 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( do { scc <- getSCC happy_var_3+ ; let str_lit = StringLiteral (getSTRINGs happy_var_3) scc+ ; ams (sLL happy_var_1 happy_var_4 (SigD (SCCFunSig (getSCC_PRAGs happy_var_1) happy_var_2 (Just ( sL1 happy_var_3 str_lit)))))+ [mo happy_var_1, mc happy_var_4] })}}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_474 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_474 = happyMonadReduce 6# 180# happyReduction_474+happyReduction_474 (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 happyOut197 happy_x_2 of { happy_var_2 -> + case happyOut292 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut147 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + ( ams (+ let inl_prag = mkInlinePragma (getSPEC_PRAGs happy_var_1)+ (NoUserInline, FunLike) (snd happy_var_2)+ in sLL happy_var_1 happy_var_6 $ SigD (SpecSig happy_var_3 (fromOL happy_var_5) inl_prag))+ (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_475 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_475 = happyMonadReduce 6# 180# happyReduction_475+happyReduction_475 (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 happyOut197 happy_x_2 of { happy_var_2 -> + case happyOut292 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut147 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + ( ams (sLL happy_var_1 happy_var_6 $ SigD (SpecSig happy_var_3 (fromOL happy_var_5)+ (mkInlinePragma (getSPEC_INLINE_PRAGs happy_var_1)+ (getSPEC_INLINE happy_var_1) (snd happy_var_2))))+ (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_476 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_476 = happyMonadReduce 4# 180# happyReduction_476+happyReduction_476 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut162 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4+ $ SigD (SpecInstSig (getSPEC_PRAGs happy_var_1) happy_var_3))+ [mo happy_var_1,mj AnnInstance happy_var_2,mc happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_477 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_477 = happyMonadReduce 3# 180# happyReduction_477+happyReduction_477 (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 happyOut255 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ SigD (MinimalSig (getMINIMAL_PRAGs happy_var_1) happy_var_2))+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn196 r))++happyReduce_478 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_478 = happySpecReduce_0 181# happyReduction_478+happyReduction_478 = happyIn197+ (([],Nothing)+ )++happyReduce_479 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_479 = happySpecReduce_1 181# happyReduction_479+happyReduction_479 happy_x_1+ = case happyOut198 happy_x_1 of { happy_var_1 -> + happyIn197+ ((fst happy_var_1,Just (snd happy_var_1))+ )}++happyReduce_480 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_480 = happySpecReduce_3 182# happyReduction_480+happyReduction_480 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn198+ (([mj AnnOpenS happy_var_1,mj AnnVal happy_var_2,mj AnnCloseS happy_var_3]+ ,ActiveAfter (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))+ )}}}++happyReduce_481 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_481 = happyReduce 4# 182# happyReduction_481+happyReduction_481 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn198+ (([mj AnnOpenS happy_var_1,mj AnnTilde happy_var_2,mj AnnVal happy_var_3+ ,mj AnnCloseS happy_var_4]+ ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))+ ) `HappyStk` happyRest}}}}++happyReduce_482 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_482 = happySpecReduce_1 183# happyReduction_482+happyReduction_482 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn199+ (let { loc = getLoc happy_var_1+ ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc happy_var_1+ ; quoterId = mkUnqual varName quoter }+ in sL1 happy_var_1 (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote)+ )}++happyReduce_483 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_483 = happySpecReduce_1 183# happyReduction_483+happyReduction_483 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn199+ (let { loc = getLoc happy_var_1+ ; ITqQuasiQuote (qual, quoter, quote, quoteSpan) = unLoc happy_var_1+ ; quoterId = mkQual varName (qual, quoter) }+ in sL (getLoc happy_var_1) (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote)+ )}++happyReduce_484 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_484 = happyMonadReduce 3# 184# happyReduction_484+happyReduction_484 (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 { happy_var_2 -> + case happyOut144 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ ExprWithTySig happy_var_1 (mkLHsSigWcType happy_var_3))+ [mu AnnDcolon happy_var_2])}}})+ ) (\r -> happyReturn (happyIn200 r))++happyReduce_485 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_485 = happyMonadReduce 3# 184# happyReduction_485+happyReduction_485 (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 { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_1 happy_var_3 placeHolderType+ HsFirstOrderApp True)+ [mu Annlarrowtail happy_var_2])}}})+ ) (\r -> happyReturn (happyIn200 r))++happyReduce_486 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_486 = happyMonadReduce 3# 184# happyReduction_486+happyReduction_486 (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 { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_3 happy_var_1 placeHolderType+ HsFirstOrderApp False)+ [mu Annrarrowtail happy_var_2])}}})+ ) (\r -> happyReturn (happyIn200 r))++happyReduce_487 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_487 = happyMonadReduce 3# 184# happyReduction_487+happyReduction_487 (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 { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_1 happy_var_3 placeHolderType+ HsHigherOrderApp True)+ [mu AnnLarrowtail happy_var_2])}}})+ ) (\r -> happyReturn (happyIn200 r))++happyReduce_488 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_488 = happyMonadReduce 3# 184# happyReduction_488+happyReduction_488 (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 { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsArrApp happy_var_3 happy_var_1 placeHolderType+ HsHigherOrderApp False)+ [mu AnnRarrowtail happy_var_2])}}})+ ) (\r -> happyReturn (happyIn200 r))++happyReduce_489 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_489 = happySpecReduce_1 184# happyReduction_489+happyReduction_489 happy_x_1+ = case happyOut201 happy_x_1 of { happy_var_1 -> + happyIn200+ (happy_var_1+ )}++happyReduce_490 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_490 = happySpecReduce_1 185# happyReduction_490+happyReduction_490 happy_x_1+ = case happyOut204 happy_x_1 of { happy_var_1 -> + happyIn201+ (happy_var_1+ )}++happyReduce_491 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_491 = happyMonadReduce 3# 185# happyReduction_491+happyReduction_491 (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 happyOut283 happy_x_2 of { happy_var_2 -> + case happyOut204 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (OpApp happy_var_1 happy_var_2 placeHolderFixity happy_var_3))+ [mj AnnVal happy_var_2])}}})+ ) (\r -> happyReturn (happyIn201 r))++happyReduce_492 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_492 = happySpecReduce_1 186# happyReduction_492+happyReduction_492 happy_x_1+ = case happyOut203 happy_x_1 of { happy_var_1 -> + happyIn202+ (happy_var_1+ )}++happyReduce_493 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_493 = happyMonadReduce 3# 186# happyReduction_493+happyReduction_493 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut202 happy_x_1 of { happy_var_1 -> + case happyOut283 happy_x_2 of { happy_var_2 -> + case happyOut203 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (OpApp happy_var_1 happy_var_2 placeHolderFixity happy_var_3))+ [mj AnnVal happy_var_2])}}})+ ) (\r -> happyReturn (happyIn202 r))++happyReduce_494 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_494 = happyMonadReduce 5# 187# happyReduction_494+happyReduction_494 (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 happyOut241 happy_x_2 of { happy_var_2 -> + case happyOut242 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut200 happy_x_5 of { happy_var_5 -> + ( ams (sLL happy_var_1 happy_var_5 $ HsLam (mkMatchGroup FromSource+ [sLL happy_var_1 happy_var_5 $ Match { m_ctxt = LambdaExpr+ , m_pats = happy_var_2:happy_var_3+ , m_grhss = unguardedGRHSs happy_var_5 }]))+ [mj AnnLam happy_var_1, mu AnnRarrow happy_var_4])}}}}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_495 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_495 = happyMonadReduce 4# 187# happyReduction_495+happyReduction_495 (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 happyOut122 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $ HsLet (snd $ unLoc happy_var_2) happy_var_4)+ (mj AnnLet happy_var_1:mj AnnIn happy_var_3+ :(fst $ unLoc happy_var_2)))}}}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_496 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_496 = happyMonadReduce 3# 187# happyReduction_496+happyReduction_496 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut230 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsLamCase+ (mkMatchGroup FromSource (snd $ unLoc happy_var_3)))+ (mj AnnLam happy_var_1:mj AnnCase happy_var_2:(fst $ unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_497 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_497 = happyMonadReduce 8# 187# happyReduction_497+happyReduction_497 (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 { happy_var_1 -> + case happyOut200 happy_x_2 of { happy_var_2 -> + case happyOut205 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut200 happy_x_5 of { happy_var_5 -> + case happyOut205 happy_x_6 of { happy_var_6 -> + case happyOutTok happy_x_7 of { happy_var_7 -> + case happyOut200 happy_x_8 of { happy_var_8 -> + ( checkDoAndIfThenElse happy_var_2 (snd happy_var_3) happy_var_5 (snd happy_var_6) happy_var_8 >>+ ams (sLL happy_var_1 happy_var_8 $ mkHsIf happy_var_2 happy_var_5 happy_var_8)+ (mj AnnIf happy_var_1:mj AnnThen happy_var_4+ :mj AnnElse happy_var_7+ :(map (\l -> mj AnnSemi l) (fst happy_var_3))+ ++(map (\l -> mj AnnSemi l) (fst happy_var_6))))}}}}}}}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_498 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_498 = happyMonadReduce 2# 187# happyReduction_498+happyReduction_498 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut237 happy_x_2 of { happy_var_2 -> + ( hintMultiWayIf (getLoc happy_var_1) >>+ ams (sLL happy_var_1 happy_var_2 $ HsMultiIf+ placeHolderType+ (reverse $ snd $ unLoc happy_var_2))+ (mj AnnIf happy_var_1:(fst $ unLoc happy_var_2)))}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_499 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_499 = happyMonadReduce 4# 187# happyReduction_499+happyReduction_499 (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 happyOut200 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut230 happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $ HsCase happy_var_2 (mkMatchGroup+ FromSource (snd $ unLoc happy_var_4)))+ (mj AnnCase happy_var_1:mj AnnOf happy_var_3+ :(fst $ unLoc happy_var_4)))}}}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_500 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_500 = happyMonadReduce 2# 187# happyReduction_500+happyReduction_500 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut208 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ NegApp happy_var_2 noSyntaxExpr)+ [mj AnnMinus happy_var_1])}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_501 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_501 = happyMonadReduce 2# 187# happyReduction_501+happyReduction_501 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut243 happy_x_2 of { happy_var_2 -> + ( ams (L (comb2 happy_var_1 happy_var_2)+ (mkHsDo DoExpr (snd $ unLoc happy_var_2)))+ (mj AnnDo happy_var_1:(fst $ unLoc happy_var_2)))}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_502 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_502 = happyMonadReduce 2# 187# happyReduction_502+happyReduction_502 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut243 happy_x_2 of { happy_var_2 -> + ( ams (L (comb2 happy_var_1 happy_var_2)+ (mkHsDo MDoExpr (snd $ unLoc happy_var_2)))+ (mj AnnMdo happy_var_1:(fst $ unLoc happy_var_2)))}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_503 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_503 = happyMonadReduce 2# 187# happyReduction_503+happyReduction_503 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut207 happy_x_1 of { happy_var_1 -> + case happyOut200 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsTickPragma (snd $ fst $ fst $ unLoc happy_var_1)+ (snd $ fst $ unLoc happy_var_1) (snd $ unLoc happy_var_1) happy_var_2)+ (fst $ fst $ fst $ unLoc happy_var_1))}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_504 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_504 = happyMonadReduce 4# 187# happyReduction_504+happyReduction_504 (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 happyOut209 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + ( checkPattern empty happy_var_2 >>= \ p ->+ checkCommand happy_var_4 >>= \ cmd ->+ ams (sLL happy_var_1 happy_var_4 $ HsProc p (sLL happy_var_1 happy_var_4 $ HsCmdTop cmd placeHolderType+ placeHolderType []))+ -- TODO: is LL right here?+ [mj AnnProc happy_var_1,mu AnnRarrow happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_505 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_505 = happyMonadReduce 4# 187# happyReduction_505+happyReduction_505 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $ HsCoreAnn (getCORE_PRAGs happy_var_1) (getStringLiteral happy_var_2) happy_var_4)+ [mo happy_var_1,mj AnnVal happy_var_2+ ,mc happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn203 r))++happyReduce_506 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_506 = happySpecReduce_1 187# happyReduction_506+happyReduction_506 happy_x_1+ = case happyOut208 happy_x_1 of { happy_var_1 -> + happyIn203+ (happy_var_1+ )}++happyReduce_507 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_507 = happySpecReduce_1 188# happyReduction_507+happyReduction_507 happy_x_1+ = case happyOut203 happy_x_1 of { happy_var_1 -> + happyIn204+ (happy_var_1+ )}++happyReduce_508 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_508 = happyMonadReduce 2# 188# happyReduction_508+happyReduction_508 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut206 happy_x_1 of { happy_var_1 -> + case happyOut200 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsSCC (snd $ fst $ unLoc happy_var_1) (snd $ unLoc happy_var_1) happy_var_2)+ (fst $ fst $ unLoc happy_var_1))}})+ ) (\r -> happyReturn (happyIn204 r))++happyReduce_509 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_509 = happySpecReduce_1 189# happyReduction_509+happyReduction_509 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn205+ (([happy_var_1],True)+ )}++happyReduce_510 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_510 = happySpecReduce_0 189# happyReduction_510+happyReduction_510 = happyIn205+ (([],False)+ )++happyReduce_511 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_511 = happyMonadReduce 3# 190# happyReduction_511+happyReduction_511 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( do scc <- getSCC happy_var_2+ ; return $ sLL happy_var_1 happy_var_3+ (([mo happy_var_1,mj AnnValStr happy_var_2+ ,mc happy_var_3],getSCC_PRAGs happy_var_1),(StringLiteral (getSTRINGs happy_var_2) scc)))}}})+ ) (\r -> happyReturn (happyIn206 r))++happyReduce_512 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_512 = happySpecReduce_3 190# happyReduction_512+happyReduction_512 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn206+ (sLL happy_var_1 happy_var_3 (([mo happy_var_1,mj AnnVal happy_var_2+ ,mc happy_var_3],getSCC_PRAGs happy_var_1)+ ,(StringLiteral NoSourceText (getVARID happy_var_2)))+ )}}}++happyReduce_513 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_513 = happyReduce 10# 191# happyReduction_513+happyReduction_513 (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 { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + case happyOutTok happy_x_7 of { happy_var_7 -> + case happyOutTok happy_x_8 of { happy_var_8 -> + case happyOutTok happy_x_9 of { happy_var_9 -> + case happyOutTok happy_x_10 of { happy_var_10 -> + happyIn207+ (sLL happy_var_1 happy_var_10 $ ((([mo happy_var_1,mj AnnVal happy_var_2+ ,mj AnnVal happy_var_3,mj AnnColon happy_var_4+ ,mj AnnVal happy_var_5,mj AnnMinus happy_var_6+ ,mj AnnVal happy_var_7,mj AnnColon happy_var_8+ ,mj AnnVal happy_var_9,mc happy_var_10],+ getGENERATED_PRAGs happy_var_1)+ ,((getStringLiteral happy_var_2)+ ,( fromInteger $ il_value $ getINTEGER happy_var_3+ , fromInteger $ il_value $ getINTEGER happy_var_5+ )+ ,( fromInteger $ il_value $ getINTEGER happy_var_7+ , fromInteger $ il_value $ getINTEGER happy_var_9+ )+ ))+ , (( getINTEGERs happy_var_3+ , getINTEGERs happy_var_5+ )+ ,( getINTEGERs happy_var_7+ , getINTEGERs happy_var_9+ )))+ ) `HappyStk` happyRest}}}}}}}}}}++happyReduce_514 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_514 = happySpecReduce_2 192# happyReduction_514+happyReduction_514 happy_x_2+ happy_x_1+ = case happyOut208 happy_x_1 of { happy_var_1 -> + case happyOut209 happy_x_2 of { happy_var_2 -> + happyIn208+ (sLL happy_var_1 happy_var_2 $ HsApp happy_var_1 happy_var_2+ )}}++happyReduce_515 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_515 = happyMonadReduce 3# 192# happyReduction_515+happyReduction_515 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut208 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut161 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsAppType happy_var_1 (mkHsWildCardBndrs happy_var_3))+ [mj AnnAt happy_var_2])}}})+ ) (\r -> happyReturn (happyIn208 r))++happyReduce_516 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_516 = happyMonadReduce 2# 192# happyReduction_516+happyReduction_516 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut209 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsStatic placeHolderNames happy_var_2)+ [mj AnnStatic happy_var_1])}})+ ) (\r -> happyReturn (happyIn208 r))++happyReduce_517 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_517 = happySpecReduce_1 192# happyReduction_517+happyReduction_517 happy_x_1+ = case happyOut209 happy_x_1 of { happy_var_1 -> + happyIn208+ (happy_var_1+ )}++happyReduce_518 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_518 = happyMonadReduce 3# 193# happyReduction_518+happyReduction_518 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut292 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut209 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ EAsPat happy_var_1 happy_var_3) [mj AnnAt happy_var_2])}}})+ ) (\r -> happyReturn (happyIn209 r))++happyReduce_519 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_519 = happyMonadReduce 2# 193# happyReduction_519+happyReduction_519 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut209 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ ELazyPat happy_var_2) [mj AnnTilde happy_var_1])}})+ ) (\r -> happyReturn (happyIn209 r))++happyReduce_520 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_520 = happySpecReduce_1 193# happyReduction_520+happyReduction_520 happy_x_1+ = case happyOut210 happy_x_1 of { happy_var_1 -> + happyIn209+ (happy_var_1+ )}++happyReduce_521 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_521 = happyMonadReduce 4# 194# happyReduction_521+happyReduction_521 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut210 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut248 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( do { r <- mkRecConstrOrUpdate happy_var_1 (comb2 happy_var_2 happy_var_4)+ (snd happy_var_3)+ ; _ <- ams (sLL happy_var_1 happy_var_4 ()) (moc happy_var_2:mcc happy_var_4:(fst happy_var_3))+ ; checkRecordSyntax (sLL happy_var_1 happy_var_4 r) })}}}})+ ) (\r -> happyReturn (happyIn210 r))++happyReduce_522 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_522 = happySpecReduce_1 194# happyReduction_522+happyReduction_522 happy_x_1+ = case happyOut211 happy_x_1 of { happy_var_1 -> + happyIn210+ (happy_var_1+ )}++happyReduce_523 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_523 = happySpecReduce_1 195# happyReduction_523+happyReduction_523 happy_x_1+ = case happyOut292 happy_x_1 of { happy_var_1 -> + happyIn211+ (sL1 happy_var_1 (HsVar $! happy_var_1)+ )}++happyReduce_524 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_524 = happySpecReduce_1 195# happyReduction_524+happyReduction_524 happy_x_1+ = case happyOut263 happy_x_1 of { happy_var_1 -> + happyIn211+ (sL1 happy_var_1 (HsVar $! happy_var_1)+ )}++happyReduce_525 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_525 = happySpecReduce_1 195# happyReduction_525+happyReduction_525 happy_x_1+ = case happyOut253 happy_x_1 of { happy_var_1 -> + happyIn211+ (sL1 happy_var_1 (HsIPVar $! unLoc happy_var_1)+ )}++happyReduce_526 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_526 = happySpecReduce_1 195# happyReduction_526+happyReduction_526 happy_x_1+ = case happyOut254 happy_x_1 of { happy_var_1 -> + happyIn211+ (sL1 happy_var_1 (HsOverLabel Nothing $! unLoc happy_var_1)+ )}++happyReduce_527 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_527 = happySpecReduce_1 195# happyReduction_527+happyReduction_527 happy_x_1+ = case happyOut306 happy_x_1 of { happy_var_1 -> + happyIn211+ (sL1 happy_var_1 (HsLit $! unLoc happy_var_1)+ )}++happyReduce_528 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_528 = happySpecReduce_1 195# happyReduction_528+happyReduction_528 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn211+ (sL (getLoc happy_var_1) (HsOverLit $! mkHsIntegral+ (getINTEGER happy_var_1) placeHolderType)+ )}++happyReduce_529 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_529 = happySpecReduce_1 195# happyReduction_529+happyReduction_529 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn211+ (sL (getLoc happy_var_1) (HsOverLit $! mkHsFractional+ (getRATIONAL happy_var_1) placeHolderType)+ )}++happyReduce_530 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_530 = happyMonadReduce 3# 195# happyReduction_530+happyReduction_530 (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 happyOut217 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (HsPar happy_var_2)) [mop happy_var_1,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_531 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_531 = happyMonadReduce 3# 195# happyReduction_531+happyReduction_531 (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 happyOut218 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( do { e <- mkSumOrTuple Boxed (comb2 happy_var_1 happy_var_3) (snd happy_var_2)+ ; ams (sLL happy_var_1 happy_var_3 e) ((mop happy_var_1:fst happy_var_2) ++ [mcp happy_var_3]) })}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_532 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_532 = happyMonadReduce 3# 195# happyReduction_532+happyReduction_532 (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 happyOut217 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (ExplicitTuple [L (gl happy_var_2)+ (Present happy_var_2)] Unboxed))+ [mo happy_var_1,mc happy_var_3])}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_533 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_533 = happyMonadReduce 3# 195# happyReduction_533+happyReduction_533 (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 happyOut218 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( do { e <- mkSumOrTuple Unboxed (comb2 happy_var_1 happy_var_3) (snd happy_var_2)+ ; ams (sLL happy_var_1 happy_var_3 e) ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_3]) })}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_534 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_534 = happyMonadReduce 3# 195# happyReduction_534+happyReduction_534 (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 happyOut221 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (snd happy_var_2)) (mos happy_var_1:mcs happy_var_3:(fst happy_var_2)))}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_535 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_535 = happyMonadReduce 3# 195# happyReduction_535+happyReduction_535 (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 happyOut227 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (snd happy_var_2)) (mo happy_var_1:mc happy_var_3:(fst happy_var_2)))}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_536 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_536 = happySpecReduce_1 195# happyReduction_536+happyReduction_536 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn211+ (sL1 happy_var_1 EWildPat+ )}++happyReduce_537 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_537 = happySpecReduce_1 195# happyReduction_537+happyReduction_537 happy_x_1+ = case happyOut212 happy_x_1 of { happy_var_1 -> + happyIn211+ (happy_var_1+ )}++happyReduce_538 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_538 = happyMonadReduce 2# 195# happyReduction_538+happyReduction_538 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut292 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr True (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_539 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_539 = happyMonadReduce 2# 195# happyReduction_539+happyReduction_539 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut263 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr True (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_540 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_540 = happyMonadReduce 2# 195# happyReduction_540+happyReduction_540 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut288 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_541 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_541 = happyMonadReduce 2# 195# happyReduction_541+happyReduction_541 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut271 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ HsBracket (VarBr False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_542 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_542 = happyMonadReduce 3# 195# happyReduction_542+happyReduction_542 (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 happyOut200 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (ExpBr happy_var_2))+ (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1, mu AnnCloseQ happy_var_3]+ else [mu AnnOpenEQ happy_var_1,mu AnnCloseQ happy_var_3]))}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_543 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_543 = happyMonadReduce 3# 195# happyReduction_543+happyReduction_543 (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 happyOut200 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (TExpBr happy_var_2))+ (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1,mc happy_var_3] else [mo happy_var_1,mc happy_var_3]))}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_544 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_544 = happyMonadReduce 3# 195# happyReduction_544+happyReduction_544 (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 happyOut151 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (TypBr happy_var_2)) [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_545 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_545 = happyMonadReduce 3# 195# happyReduction_545+happyReduction_545 (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 happyOut201 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( checkPattern empty happy_var_2 >>= \p ->+ ams (sLL happy_var_1 happy_var_3 $ HsBracket (PatBr p))+ [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_546 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_546 = happyMonadReduce 3# 195# happyReduction_546+happyReduction_546 (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 happyOut215 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsBracket (DecBrL (snd happy_var_2)))+ (mo happy_var_1:mu AnnCloseQ happy_var_3:fst happy_var_2))}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_547 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_547 = happySpecReduce_1 195# happyReduction_547+happyReduction_547 happy_x_1+ = case happyOut199 happy_x_1 of { happy_var_1 -> + happyIn211+ (sL1 happy_var_1 (HsSpliceE (unLoc happy_var_1))+ )}++happyReduce_548 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_548 = happyMonadReduce 4# 195# happyReduction_548+happyReduction_548 (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 happyOut211 happy_x_2 of { happy_var_2 -> + case happyOut213 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + ( ams (sLL happy_var_1 happy_var_4 $ HsArrForm happy_var_2+ Nothing (reverse happy_var_3))+ [mu AnnOpenB happy_var_1,mu AnnCloseB happy_var_4])}}}})+ ) (\r -> happyReturn (happyIn211 r))++happyReduce_549 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_549 = happyMonadReduce 1# 196# happyReduction_549+happyReduction_549 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( ams (sL1 happy_var_1 $ mkHsSpliceE HasDollar+ (sL1 happy_var_1 $ HsVar (sL1 happy_var_1 (mkUnqual varName+ (getTH_ID_SPLICE happy_var_1)))))+ [mj AnnThIdSplice happy_var_1])})+ ) (\r -> happyReturn (happyIn212 r))++happyReduce_550 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_550 = happyMonadReduce 3# 196# happyReduction_550+happyReduction_550 (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 happyOut200 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ mkHsSpliceE HasParens happy_var_2)+ [mj AnnOpenPE happy_var_1,mj AnnCloseP happy_var_3])}}})+ ) (\r -> happyReturn (happyIn212 r))++happyReduce_551 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_551 = happyMonadReduce 1# 196# happyReduction_551+happyReduction_551 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( ams (sL1 happy_var_1 $ mkHsSpliceTE HasDollar+ (sL1 happy_var_1 $ HsVar (sL1 happy_var_1 (mkUnqual varName+ (getTH_ID_TY_SPLICE happy_var_1)))))+ [mj AnnThIdTySplice happy_var_1])})+ ) (\r -> happyReturn (happyIn212 r))++happyReduce_552 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_552 = happyMonadReduce 3# 196# happyReduction_552+happyReduction_552 (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 happyOut200 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ mkHsSpliceTE HasParens happy_var_2)+ [mj AnnOpenPTE happy_var_1,mj AnnCloseP happy_var_3])}}})+ ) (\r -> happyReturn (happyIn212 r))++happyReduce_553 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_553 = happySpecReduce_2 197# happyReduction_553+happyReduction_553 happy_x_2+ happy_x_1+ = case happyOut213 happy_x_1 of { happy_var_1 -> + case happyOut214 happy_x_2 of { happy_var_2 -> + happyIn213+ (happy_var_2 : happy_var_1+ )}}++happyReduce_554 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_554 = happySpecReduce_0 197# happyReduction_554+happyReduction_554 = happyIn213+ ([]+ )++happyReduce_555 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_555 = happyMonadReduce 1# 198# happyReduction_555+happyReduction_555 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut211 happy_x_1 of { happy_var_1 -> + ( checkCommand happy_var_1 >>= \ cmd ->+ return (sL1 happy_var_1 $ HsCmdTop cmd+ placeHolderType placeHolderType []))})+ ) (\r -> happyReturn (happyIn214 r))++happyReduce_556 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_556 = happySpecReduce_3 199# happyReduction_556+happyReduction_556 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut216 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn215+ (([mj AnnOpenC happy_var_1+ ,mj AnnCloseC happy_var_3],happy_var_2)+ )}}}++happyReduce_557 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_557 = happySpecReduce_3 199# happyReduction_557+happyReduction_557 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut216 happy_x_2 of { happy_var_2 -> + happyIn215+ (([],happy_var_2)+ )}++happyReduce_558 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_558 = happySpecReduce_1 200# happyReduction_558+happyReduction_558 happy_x_1+ = case happyOut76 happy_x_1 of { happy_var_1 -> + happyIn216+ (cvTopDecls happy_var_1+ )}++happyReduce_559 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_559 = happySpecReduce_1 200# happyReduction_559+happyReduction_559 happy_x_1+ = case happyOut75 happy_x_1 of { happy_var_1 -> + happyIn216+ (cvTopDecls happy_var_1+ )}++happyReduce_560 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_560 = happySpecReduce_1 201# happyReduction_560+happyReduction_560 happy_x_1+ = case happyOut200 happy_x_1 of { happy_var_1 -> + happyIn217+ (happy_var_1+ )}++happyReduce_561 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_561 = happySpecReduce_2 201# happyReduction_561+happyReduction_561 happy_x_2+ happy_x_1+ = case happyOut201 happy_x_1 of { happy_var_1 -> + case happyOut283 happy_x_2 of { happy_var_2 -> + happyIn217+ (sLL happy_var_1 happy_var_2 $ SectionL happy_var_1 happy_var_2+ )}}++happyReduce_562 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_562 = happySpecReduce_2 201# happyReduction_562+happyReduction_562 happy_x_2+ happy_x_1+ = case happyOut284 happy_x_1 of { happy_var_1 -> + case happyOut201 happy_x_2 of { happy_var_2 -> + happyIn217+ (sLL happy_var_1 happy_var_2 $ SectionR happy_var_1 happy_var_2+ )}}++happyReduce_563 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_563 = happyMonadReduce 3# 201# happyReduction_563+happyReduction_563 (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 { happy_var_2 -> + case happyOut217 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ EViewPat happy_var_1 happy_var_3) [mu AnnRarrow happy_var_2])}}})+ ) (\r -> happyReturn (happyIn217 r))++happyReduce_564 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_564 = happyMonadReduce 2# 202# happyReduction_564+happyReduction_564 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOut219 happy_x_2 of { happy_var_2 -> + ( do { addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2)+ ; return ([],Tuple ((sL1 happy_var_1 (Present happy_var_1)) : snd happy_var_2)) })}})+ ) (\r -> happyReturn (happyIn218 r))++happyReduce_565 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_565 = happySpecReduce_2 202# happyReduction_565+happyReduction_565 happy_x_2+ happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOut311 happy_x_2 of { happy_var_2 -> + happyIn218+ ((mvbars (fst happy_var_2), Sum 1 (snd happy_var_2 + 1) happy_var_1)+ )}}++happyReduce_566 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_566 = happyMonadReduce 2# 202# happyReduction_566+happyReduction_566 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut309 happy_x_1 of { happy_var_1 -> + case happyOut220 happy_x_2 of { happy_var_2 -> + ( do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (fst happy_var_1)+ ; return+ ([],Tuple (map (\l -> L l missingTupArg) (fst happy_var_1) ++ happy_var_2)) })}})+ ) (\r -> happyReturn (happyIn218 r))++happyReduce_567 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_567 = happySpecReduce_3 202# happyReduction_567+happyReduction_567 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut311 happy_x_1 of { happy_var_1 -> + case happyOut217 happy_x_2 of { happy_var_2 -> + case happyOut310 happy_x_3 of { happy_var_3 -> + happyIn218+ ((mvbars (fst happy_var_1) ++ mvbars (fst happy_var_3), Sum (snd happy_var_1 + 1) (snd happy_var_1 + snd happy_var_3 + 1) happy_var_2)+ )}}}++happyReduce_568 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_568 = happyMonadReduce 2# 203# happyReduction_568+happyReduction_568 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut309 happy_x_1 of { happy_var_1 -> + case happyOut220 happy_x_2 of { happy_var_2 -> + ( do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (tail $ fst happy_var_1)+ ; return (+ (head $ fst happy_var_1+ ,(map (\l -> L l missingTupArg) (tail $ fst happy_var_1)) ++ happy_var_2)) })}})+ ) (\r -> happyReturn (happyIn219 r))++happyReduce_569 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_569 = happyMonadReduce 2# 204# happyReduction_569+happyReduction_569 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOut219 happy_x_2 of { happy_var_2 -> + ( addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2) >>+ return ((L (gl happy_var_1) (Present happy_var_1)) : snd happy_var_2))}})+ ) (\r -> happyReturn (happyIn220 r))++happyReduce_570 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_570 = happySpecReduce_1 204# happyReduction_570+happyReduction_570 happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + happyIn220+ ([L (gl happy_var_1) (Present happy_var_1)]+ )}++happyReduce_571 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_571 = happySpecReduce_0 204# happyReduction_571+happyReduction_571 = happyIn220+ ([noLoc missingTupArg]+ )++happyReduce_572 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_572 = happySpecReduce_1 205# happyReduction_572+happyReduction_572 happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + happyIn221+ (([],ExplicitList placeHolderType Nothing [happy_var_1])+ )}++happyReduce_573 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_573 = happySpecReduce_1 205# happyReduction_573+happyReduction_573 happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + happyIn221+ (([],ExplicitList placeHolderType Nothing+ (reverse (unLoc happy_var_1)))+ )}++happyReduce_574 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_574 = happySpecReduce_2 205# happyReduction_574+happyReduction_574 happy_x_2+ happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn221+ (([mj AnnDotdot happy_var_2],+ ArithSeq noPostTcExpr Nothing (From happy_var_1))+ )}}++happyReduce_575 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_575 = happyReduce 4# 205# happyReduction_575+happyReduction_575 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn221+ (([mj AnnComma happy_var_2,mj AnnDotdot happy_var_4],+ ArithSeq noPostTcExpr Nothing+ (FromThen happy_var_1 happy_var_3))+ ) `HappyStk` happyRest}}}}++happyReduce_576 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_576 = happySpecReduce_3 205# happyReduction_576+happyReduction_576 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + happyIn221+ (([mj AnnDotdot happy_var_2],+ ArithSeq noPostTcExpr Nothing+ (FromTo happy_var_1 happy_var_3))+ )}}}++happyReduce_577 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_577 = happyReduce 5# 205# happyReduction_577+happyReduction_577 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut200 happy_x_5 of { happy_var_5 -> + happyIn221+ (([mj AnnComma happy_var_2,mj AnnDotdot happy_var_4],+ ArithSeq noPostTcExpr Nothing+ (FromThenTo happy_var_1 happy_var_3 happy_var_5))+ ) `HappyStk` happyRest}}}}}++happyReduce_578 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_578 = happyMonadReduce 3# 205# happyReduction_578+happyReduction_578 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + ( checkMonadComp >>= \ ctxt ->+ return ([mj AnnVbar happy_var_2],+ mkHsComp ctxt (unLoc happy_var_3) happy_var_1))}}})+ ) (\r -> happyReturn (happyIn221 r))++happyReduce_579 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_579 = happyMonadReduce 3# 206# happyReduction_579+happyReduction_579 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut222 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut217 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1)+ AnnComma (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 (((:) $! happy_var_3) $! unLoc happy_var_1)))}}})+ ) (\r -> happyReturn (happyIn222 r))++happyReduce_580 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_580 = happyMonadReduce 3# 206# happyReduction_580+happyReduction_580 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut217 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 [happy_var_3,happy_var_1]))}}})+ ) (\r -> happyReturn (happyIn222 r))++happyReduce_581 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_581 = happySpecReduce_1 207# happyReduction_581+happyReduction_581 happy_x_1+ = case happyOut224 happy_x_1 of { happy_var_1 -> + happyIn223+ (case (unLoc happy_var_1) of+ [qs] -> sL1 happy_var_1 qs+ -- We just had one thing in our "parallel" list so+ -- we simply return that thing directly++ qss -> sL1 happy_var_1 [sL1 happy_var_1 $ ParStmt [ParStmtBlock qs [] noSyntaxExpr |+ qs <- qss]+ noExpr noSyntaxExpr placeHolderType]+ -- We actually found some actual parallel lists so+ -- we wrap them into as a ParStmt+ )}++happyReduce_582 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_582 = happyMonadReduce 3# 208# happyReduction_582+happyReduction_582 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut225 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut224 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 (reverse (unLoc happy_var_1) : unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn224 r))++happyReduce_583 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_583 = happySpecReduce_1 208# happyReduction_583+happyReduction_583 happy_x_1+ = case happyOut225 happy_x_1 of { happy_var_1 -> + happyIn224+ (L (getLoc happy_var_1) [reverse (unLoc happy_var_1)]+ )}++happyReduce_584 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_584 = happyMonadReduce 3# 209# happyReduction_584+happyReduction_584 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut225 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut226 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+ ams (sLL happy_var_1 happy_var_3 ()) (fst $ unLoc happy_var_3) >>+ return (sLL happy_var_1 happy_var_3 [sLL happy_var_1 happy_var_3 ((snd $ unLoc happy_var_3) (reverse (unLoc happy_var_1)))]))}}})+ ) (\r -> happyReturn (happyIn225 r))++happyReduce_585 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_585 = happyMonadReduce 3# 209# happyReduction_585+happyReduction_585 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut225 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut247 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+ ) (\r -> happyReturn (happyIn225 r))++happyReduce_586 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_586 = happyMonadReduce 1# 209# happyReduction_586+happyReduction_586 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut226 happy_x_1 of { happy_var_1 -> + ( ams happy_var_1 (fst $ unLoc happy_var_1) >>+ return (sLL happy_var_1 happy_var_1 [L (getLoc happy_var_1) ((snd $ unLoc happy_var_1) [])]))})+ ) (\r -> happyReturn (happyIn225 r))++happyReduce_587 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_587 = happySpecReduce_1 209# happyReduction_587+happyReduction_587 happy_x_1+ = case happyOut247 happy_x_1 of { happy_var_1 -> + happyIn225+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_588 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_588 = happySpecReduce_2 210# happyReduction_588+happyReduction_588 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut200 happy_x_2 of { happy_var_2 -> + happyIn226+ (sLL happy_var_1 happy_var_2 ([mj AnnThen happy_var_1], \ss -> (mkTransformStmt ss happy_var_2))+ )}}++happyReduce_589 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_589 = happyReduce 4# 210# happyReduction_589+happyReduction_589 (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 happyOut200 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + happyIn226+ (sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnBy happy_var_3],\ss -> (mkTransformByStmt ss happy_var_2 happy_var_4))+ ) `HappyStk` happyRest}}}}++happyReduce_590 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_590 = happyReduce 4# 210# happyReduction_590+happyReduction_590 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + happyIn226+ (sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnUsing happy_var_3], \ss -> (mkGroupUsingStmt ss happy_var_4))+ ) `HappyStk` happyRest}}}}++happyReduce_591 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_591 = happyReduce 6# 210# happyReduction_591+happyReduction_591 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + case happyOut200 happy_x_6 of { happy_var_6 -> + happyIn226+ (sLL happy_var_1 happy_var_6 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnBy happy_var_3,mj AnnUsing happy_var_5], \ss -> (mkGroupByUsingStmt ss happy_var_4 happy_var_6))+ ) `HappyStk` happyRest}}}}}}++happyReduce_592 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_592 = happySpecReduce_0 211# happyReduction_592+happyReduction_592 = happyIn227+ (([],ExplicitPArr placeHolderType [])+ )++happyReduce_593 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_593 = happySpecReduce_1 211# happyReduction_593+happyReduction_593 happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + happyIn227+ (([],ExplicitPArr placeHolderType [happy_var_1])+ )}++happyReduce_594 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_594 = happySpecReduce_1 211# happyReduction_594+happyReduction_594 happy_x_1+ = case happyOut222 happy_x_1 of { happy_var_1 -> + happyIn227+ (([],ExplicitPArr placeHolderType+ (reverse (unLoc happy_var_1)))+ )}++happyReduce_595 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_595 = happySpecReduce_3 211# happyReduction_595+happyReduction_595 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + happyIn227+ (([mj AnnDotdot happy_var_2]+ ,PArrSeq noPostTcExpr (FromTo happy_var_1 happy_var_3))+ )}}}++happyReduce_596 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_596 = happyReduce 5# 211# happyReduction_596+happyReduction_596 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut200 happy_x_5 of { happy_var_5 -> + happyIn227+ (([mj AnnComma happy_var_2,mj AnnDotdot happy_var_4]+ ,PArrSeq noPostTcExpr (FromThenTo happy_var_1 happy_var_3 happy_var_5))+ ) `HappyStk` happyRest}}}}}++happyReduce_597 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_597 = happySpecReduce_3 211# happyReduction_597+happyReduction_597 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut217 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut223 happy_x_3 of { happy_var_3 -> + happyIn227+ (([mj AnnVbar happy_var_2],mkHsComp PArrComp (unLoc happy_var_3) happy_var_1)+ )}}}++happyReduce_598 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_598 = happySpecReduce_1 212# happyReduction_598+happyReduction_598 happy_x_1+ = case happyOut229 happy_x_1 of { happy_var_1 -> + happyIn228+ (L (getLoc happy_var_1) (reverse (unLoc happy_var_1))+ )}++happyReduce_599 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_599 = happyMonadReduce 3# 213# happyReduction_599+happyReduction_599 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut229 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut247 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma+ (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+ ) (\r -> happyReturn (happyIn229 r))++happyReduce_600 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_600 = happySpecReduce_1 213# happyReduction_600+happyReduction_600 happy_x_1+ = case happyOut247 happy_x_1 of { happy_var_1 -> + happyIn229+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_601 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_601 = happySpecReduce_3 214# happyReduction_601+happyReduction_601 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut231 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn230+ (sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))+ ,(reverse (snd $ unLoc happy_var_2)))+ )}}}++happyReduce_602 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_602 = happySpecReduce_3 214# happyReduction_602+happyReduction_602 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut231 happy_x_2 of { happy_var_2 -> + happyIn230+ (L (getLoc happy_var_2) (fst $ unLoc happy_var_2+ ,(reverse (snd $ unLoc happy_var_2)))+ )}++happyReduce_603 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_603 = happySpecReduce_2 214# happyReduction_603+happyReduction_603 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn230+ (noLoc ([moc happy_var_1,mcc happy_var_2],[])+ )}}++happyReduce_604 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_604 = happySpecReduce_2 214# happyReduction_604+happyReduction_604 happy_x_2+ happy_x_1+ = happyIn230+ (noLoc ([],[])+ )++happyReduce_605 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_605 = happySpecReduce_1 215# happyReduction_605+happyReduction_605 happy_x_1+ = case happyOut232 happy_x_1 of { happy_var_1 -> + happyIn231+ (sL1 happy_var_1 (fst $ unLoc happy_var_1,snd $ unLoc happy_var_1)+ )}++happyReduce_606 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_606 = happySpecReduce_2 215# happyReduction_606+happyReduction_606 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut231 happy_x_2 of { happy_var_2 -> + happyIn231+ (sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_1:(fst $ unLoc happy_var_2))+ ,snd $ unLoc happy_var_2)+ )}}++happyReduce_607 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_607 = happyMonadReduce 3# 216# happyReduction_607+happyReduction_607 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut232 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut233 happy_x_3 of { happy_var_3 -> + ( if null (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ ,[happy_var_3]))+ else (ams (head $ snd $ unLoc happy_var_1)+ (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))+ >> return (sLL happy_var_1 happy_var_3 ([],happy_var_3 : (snd $ unLoc happy_var_1))) ))}}})+ ) (\r -> happyReturn (happyIn232 r))++happyReduce_608 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_608 = happyMonadReduce 2# 216# happyReduction_608+happyReduction_608 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut232 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( if null (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ ,snd $ unLoc happy_var_1))+ else (ams (head $ snd $ unLoc happy_var_1)+ (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))+ >> return (sLL happy_var_1 happy_var_2 ([],snd $ unLoc happy_var_1))))}})+ ) (\r -> happyReturn (happyIn232 r))++happyReduce_609 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_609 = happySpecReduce_1 216# happyReduction_609+happyReduction_609 happy_x_1+ = case happyOut233 happy_x_1 of { happy_var_1 -> + happyIn232+ (sL1 happy_var_1 ([],[happy_var_1])+ )}++happyReduce_610 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_610 = happyMonadReduce 2# 217# happyReduction_610+happyReduction_610 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut239 happy_x_1 of { happy_var_1 -> + case happyOut234 happy_x_2 of { happy_var_2 -> + (ams (sLL happy_var_1 happy_var_2 (Match { m_ctxt = CaseAlt+ , m_pats = [happy_var_1]+ , m_grhss = snd $ unLoc happy_var_2 }))+ (fst $ unLoc happy_var_2))}})+ ) (\r -> happyReturn (happyIn233 r))++happyReduce_611 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_611 = happySpecReduce_2 218# happyReduction_611+happyReduction_611 happy_x_2+ happy_x_1+ = case happyOut235 happy_x_1 of { happy_var_1 -> + case happyOut123 happy_x_2 of { happy_var_2 -> + happyIn234+ (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_2,+ GRHSs (unLoc happy_var_1) (snd $ unLoc happy_var_2))+ )}}++happyReduce_612 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_612 = happyMonadReduce 2# 219# happyReduction_612+happyReduction_612 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut200 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 (unguardedRHS (comb2 happy_var_1 happy_var_2) happy_var_2))+ [mu AnnRarrow happy_var_1])}})+ ) (\r -> happyReturn (happyIn235 r))++happyReduce_613 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_613 = happySpecReduce_1 219# happyReduction_613+happyReduction_613 happy_x_1+ = case happyOut236 happy_x_1 of { happy_var_1 -> + happyIn235+ (sL1 happy_var_1 (reverse (unLoc happy_var_1))+ )}++happyReduce_614 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_614 = happySpecReduce_2 220# happyReduction_614+happyReduction_614 happy_x_2+ happy_x_1+ = case happyOut236 happy_x_1 of { happy_var_1 -> + case happyOut238 happy_x_2 of { happy_var_2 -> + happyIn236+ (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)+ )}}++happyReduce_615 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_615 = happySpecReduce_1 220# happyReduction_615+happyReduction_615 happy_x_1+ = case happyOut238 happy_x_1 of { happy_var_1 -> + happyIn236+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_616 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_616 = happySpecReduce_3 221# happyReduction_616+happyReduction_616 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut236 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn237+ (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3],unLoc happy_var_2)+ )}}}++happyReduce_617 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_617 = happySpecReduce_2 221# happyReduction_617+happyReduction_617 happy_x_2+ happy_x_1+ = case happyOut236 happy_x_1 of { happy_var_1 -> + happyIn237+ (sL1 happy_var_1 ([],unLoc happy_var_1)+ )}++happyReduce_618 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_618 = happyMonadReduce 4# 222# happyReduction_618+happyReduction_618 (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 happyOut228 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut200 happy_x_4 of { happy_var_4 -> + ( ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS (unLoc happy_var_2) happy_var_4)+ [mj AnnVbar happy_var_1,mu AnnRarrow happy_var_3])}}}})+ ) (\r -> happyReturn (happyIn238 r))++happyReduce_619 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_619 = happyMonadReduce 1# 223# happyReduction_619+happyReduction_619 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut200 happy_x_1 of { happy_var_1 -> + ( checkPattern empty happy_var_1)})+ ) (\r -> happyReturn (happyIn239 r))++happyReduce_620 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_620 = happyMonadReduce 2# 223# happyReduction_620+happyReduction_620 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut209 happy_x_2 of { happy_var_2 -> + ( amms (checkPattern empty (sLL happy_var_1 happy_var_2 (SectionR+ (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)))+ [mj AnnBang happy_var_1])}})+ ) (\r -> happyReturn (happyIn239 r))++happyReduce_621 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_621 = happyMonadReduce 1# 224# happyReduction_621+happyReduction_621 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut200 happy_x_1 of { happy_var_1 -> + ( checkPattern+ (text "Possibly caused by a missing 'do'?") happy_var_1)})+ ) (\r -> happyReturn (happyIn240 r))++happyReduce_622 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_622 = happyMonadReduce 2# 224# happyReduction_622+happyReduction_622 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut209 happy_x_2 of { happy_var_2 -> + ( amms (checkPattern+ (text "Possibly caused by a missing 'do'?")+ (sLL happy_var_1 happy_var_2 (SectionR (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)))+ [mj AnnBang happy_var_1])}})+ ) (\r -> happyReturn (happyIn240 r))++happyReduce_623 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_623 = happyMonadReduce 1# 225# happyReduction_623+happyReduction_623 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut209 happy_x_1 of { happy_var_1 -> + ( checkPattern empty happy_var_1)})+ ) (\r -> happyReturn (happyIn241 r))++happyReduce_624 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_624 = happyMonadReduce 2# 225# happyReduction_624+happyReduction_624 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut209 happy_x_2 of { happy_var_2 -> + ( amms (checkPattern empty+ (sLL happy_var_1 happy_var_2 (SectionR+ (sL1 happy_var_1 (HsVar (sL1 happy_var_1 bang_RDR))) happy_var_2)))+ [mj AnnBang happy_var_1])}})+ ) (\r -> happyReturn (happyIn241 r))++happyReduce_625 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_625 = happySpecReduce_2 226# happyReduction_625+happyReduction_625 happy_x_2+ happy_x_1+ = case happyOut241 happy_x_1 of { happy_var_1 -> + case happyOut242 happy_x_2 of { happy_var_2 -> + happyIn242+ (happy_var_1 : happy_var_2+ )}}++happyReduce_626 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_626 = happySpecReduce_0 226# happyReduction_626+happyReduction_626 = happyIn242+ ([]+ )++happyReduce_627 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_627 = happySpecReduce_3 227# happyReduction_627+happyReduction_627 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut244 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn243+ (sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))+ ,(reverse $ snd $ unLoc happy_var_2))+ )}}}++happyReduce_628 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_628 = happySpecReduce_3 227# happyReduction_628+happyReduction_628 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut244 happy_x_2 of { happy_var_2 -> + happyIn243+ (L (gl happy_var_2) (fst $ unLoc happy_var_2+ ,reverse $ snd $ unLoc happy_var_2)+ )}++happyReduce_629 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_629 = happyMonadReduce 3# 228# happyReduction_629+happyReduction_629 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut244 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut246 happy_x_3 of { happy_var_3 -> + ( if null (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+ ,happy_var_3 : (snd $ unLoc happy_var_1)))+ else do+ { ams (head $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+ ; return $ sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,happy_var_3 :(snd $ unLoc happy_var_1)) })}}})+ ) (\r -> happyReturn (happyIn244 r))++happyReduce_630 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_630 = happyMonadReduce 2# 228# happyReduction_630+happyReduction_630 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut244 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( if null (snd $ unLoc happy_var_1)+ then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1),snd $ unLoc happy_var_1))+ else do+ { ams (head $ snd $ unLoc happy_var_1)+ [mj AnnSemi happy_var_2]+ ; return happy_var_1 })}})+ ) (\r -> happyReturn (happyIn244 r))++happyReduce_631 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_631 = happySpecReduce_1 228# happyReduction_631+happyReduction_631 happy_x_1+ = case happyOut246 happy_x_1 of { happy_var_1 -> + happyIn244+ (sL1 happy_var_1 ([],[happy_var_1])+ )}++happyReduce_632 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_632 = happySpecReduce_0 228# happyReduction_632+happyReduction_632 = happyIn244+ (noLoc ([],[])+ )++happyReduce_633 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_633 = happySpecReduce_1 229# happyReduction_633+happyReduction_633 happy_x_1+ = case happyOut246 happy_x_1 of { happy_var_1 -> + happyIn245+ (Just happy_var_1+ )}++happyReduce_634 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_634 = happySpecReduce_0 229# happyReduction_634+happyReduction_634 = happyIn245+ (Nothing+ )++happyReduce_635 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_635 = happySpecReduce_1 230# happyReduction_635+happyReduction_635 happy_x_1+ = case happyOut247 happy_x_1 of { happy_var_1 -> + happyIn246+ (happy_var_1+ )}++happyReduce_636 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_636 = happyMonadReduce 2# 230# happyReduction_636+happyReduction_636 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut243 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ mkRecStmt (snd $ unLoc happy_var_2))+ (mj AnnRec happy_var_1:(fst $ unLoc happy_var_2)))}})+ ) (\r -> happyReturn (happyIn246 r))++happyReduce_637 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_637 = happyMonadReduce 3# 231# happyReduction_637+happyReduction_637 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut240 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ mkBindStmt happy_var_1 happy_var_3)+ [mu AnnLarrow happy_var_2])}}})+ ) (\r -> happyReturn (happyIn247 r))++happyReduce_638 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_638 = happySpecReduce_1 231# happyReduction_638+happyReduction_638 happy_x_1+ = case happyOut200 happy_x_1 of { happy_var_1 -> + happyIn247+ (sL1 happy_var_1 $ mkBodyStmt happy_var_1+ )}++happyReduce_639 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_639 = happyMonadReduce 2# 231# happyReduction_639+happyReduction_639 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut122 happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2$ LetStmt (snd $ unLoc happy_var_2))+ (mj AnnLet happy_var_1:(fst $ unLoc happy_var_2)))}})+ ) (\r -> happyReturn (happyIn247 r))++happyReduce_640 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_640 = happySpecReduce_1 232# happyReduction_640+happyReduction_640 happy_x_1+ = case happyOut249 happy_x_1 of { happy_var_1 -> + happyIn248+ (happy_var_1+ )}++happyReduce_641 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_641 = happySpecReduce_0 232# happyReduction_641+happyReduction_641 = happyIn248+ (([],([], False))+ )++happyReduce_642 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_642 = happyMonadReduce 3# 233# happyReduction_642+happyReduction_642 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut250 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut249 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+ return (case happy_var_3 of (ma,(flds, dd)) -> (ma,(happy_var_1 : flds, dd))))}}})+ ) (\r -> happyReturn (happyIn249 r))++happyReduce_643 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_643 = happySpecReduce_1 233# happyReduction_643+happyReduction_643 happy_x_1+ = case happyOut250 happy_x_1 of { happy_var_1 -> + happyIn249+ (([],([happy_var_1], False))+ )}++happyReduce_644 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_644 = happySpecReduce_1 233# happyReduction_644+happyReduction_644 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn249+ (([mj AnnDotdot happy_var_1],([], True))+ )}++happyReduce_645 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_645 = happyMonadReduce 3# 234# happyReduction_645+happyReduction_645 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut292 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut217 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) happy_var_3 False)+ [mj AnnEqual happy_var_2])}}})+ ) (\r -> happyReturn (happyIn250 r))++happyReduce_646 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_646 = happySpecReduce_1 234# happyReduction_646+happyReduction_646 happy_x_1+ = case happyOut292 happy_x_1 of { happy_var_1 -> + happyIn250+ (sLL happy_var_1 happy_var_1 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) placeHolderPunRhs True+ )}++happyReduce_647 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_647 = happyMonadReduce 3# 235# happyReduction_647+happyReduction_647 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut251 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut252 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>+ return (let { this = happy_var_3; rest = unLoc happy_var_1 }+ in rest `seq` this `seq` sLL happy_var_1 happy_var_3 (this : rest)))}}})+ ) (\r -> happyReturn (happyIn251 r))++happyReduce_648 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_648 = happyMonadReduce 2# 235# happyReduction_648+happyReduction_648 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut251 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+ ) (\r -> happyReturn (happyIn251 r))++happyReduce_649 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_649 = happySpecReduce_1 235# happyReduction_649+happyReduction_649 happy_x_1+ = case happyOut252 happy_x_1 of { happy_var_1 -> + happyIn251+ (let this = happy_var_1 in this `seq` sL1 happy_var_1 [this]+ )}++happyReduce_650 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_650 = happyMonadReduce 3# 236# happyReduction_650+happyReduction_650 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut253 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut200 happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (IPBind (Left happy_var_1) happy_var_3))+ [mj AnnEqual happy_var_2])}}})+ ) (\r -> happyReturn (happyIn252 r))++happyReduce_651 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_651 = happySpecReduce_1 237# happyReduction_651+happyReduction_651 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn253+ (sL1 happy_var_1 (HsIPName (getIPDUPVARID happy_var_1))+ )}++happyReduce_652 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_652 = happySpecReduce_1 238# happyReduction_652+happyReduction_652 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn254+ (sL1 happy_var_1 (getLABELVARID happy_var_1)+ )}++happyReduce_653 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_653 = happySpecReduce_1 239# happyReduction_653+happyReduction_653 happy_x_1+ = case happyOut256 happy_x_1 of { happy_var_1 -> + happyIn255+ (happy_var_1+ )}++happyReduce_654 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_654 = happySpecReduce_0 239# happyReduction_654+happyReduction_654 = happyIn255+ (noLoc mkTrue+ )++happyReduce_655 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_655 = happySpecReduce_1 240# happyReduction_655+happyReduction_655 happy_x_1+ = case happyOut257 happy_x_1 of { happy_var_1 -> + happyIn256+ (happy_var_1+ )}++happyReduce_656 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_656 = happyMonadReduce 3# 240# happyReduction_656+happyReduction_656 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut257 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut256 happy_x_3 of { happy_var_3 -> + ( aa happy_var_1 (AnnVbar, happy_var_2)+ >> return (sLL happy_var_1 happy_var_3 (Or [happy_var_1,happy_var_3])))}}})+ ) (\r -> happyReturn (happyIn256 r))++happyReduce_657 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_657 = happySpecReduce_1 241# happyReduction_657+happyReduction_657 happy_x_1+ = case happyOut258 happy_x_1 of { happy_var_1 -> + happyIn257+ (sLL (head happy_var_1) (last happy_var_1) (And (happy_var_1))+ )}++happyReduce_658 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_658 = happySpecReduce_1 242# happyReduction_658+happyReduction_658 happy_x_1+ = case happyOut259 happy_x_1 of { happy_var_1 -> + happyIn258+ ([happy_var_1]+ )}++happyReduce_659 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_659 = happyMonadReduce 3# 242# happyReduction_659+happyReduction_659 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut259 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut258 happy_x_3 of { happy_var_3 -> + ( aa happy_var_1 (AnnComma, happy_var_2) >> return (happy_var_1 : happy_var_3))}}})+ ) (\r -> happyReturn (happyIn258 r))++happyReduce_660 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_660 = happyMonadReduce 3# 243# happyReduction_660+happyReduction_660 (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 happyOut256 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (Parens happy_var_2)) [mop happy_var_1,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn259 r))++happyReduce_661 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_661 = happySpecReduce_1 243# happyReduction_661+happyReduction_661 happy_x_1+ = case happyOut261 happy_x_1 of { happy_var_1 -> + happyIn259+ (sL1 happy_var_1 (Var happy_var_1)+ )}++happyReduce_662 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_662 = happySpecReduce_1 244# happyReduction_662+happyReduction_662 happy_x_1+ = case happyOut261 happy_x_1 of { happy_var_1 -> + happyIn260+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_663 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_663 = happyMonadReduce 3# 244# happyReduction_663+happyReduction_663 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut261 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut260 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn260 r))++happyReduce_664 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_664 = happySpecReduce_1 245# happyReduction_664+happyReduction_664 happy_x_1+ = case happyOut291 happy_x_1 of { happy_var_1 -> + happyIn261+ (happy_var_1+ )}++happyReduce_665 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_665 = happySpecReduce_1 245# happyReduction_665+happyReduction_665 happy_x_1+ = case happyOut265 happy_x_1 of { happy_var_1 -> + happyIn261+ (happy_var_1+ )}++happyReduce_666 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_666 = happySpecReduce_1 246# happyReduction_666+happyReduction_666 happy_x_1+ = case happyOut264 happy_x_1 of { happy_var_1 -> + happyIn262+ (happy_var_1+ )}++happyReduce_667 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_667 = happySpecReduce_1 246# happyReduction_667+happyReduction_667 happy_x_1+ = case happyOut267 happy_x_1 of { happy_var_1 -> + happyIn262+ (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))+ )}++happyReduce_668 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_668 = happySpecReduce_1 247# happyReduction_668+happyReduction_668 happy_x_1+ = case happyOut264 happy_x_1 of { happy_var_1 -> + happyIn263+ (happy_var_1+ )}++happyReduce_669 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_669 = happySpecReduce_1 247# happyReduction_669+happyReduction_669 happy_x_1+ = case happyOut268 happy_x_1 of { happy_var_1 -> + happyIn263+ (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))+ )}++happyReduce_670 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_670 = happySpecReduce_1 248# happyReduction_670+happyReduction_670 happy_x_1+ = case happyOut302 happy_x_1 of { happy_var_1 -> + happyIn264+ (happy_var_1+ )}++happyReduce_671 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_671 = happyMonadReduce 3# 248# happyReduction_671+happyReduction_671 (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 happyOut304 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn264 r))++happyReduce_672 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_672 = happySpecReduce_1 249# happyReduction_672+happyReduction_672 happy_x_1+ = case happyOut303 happy_x_1 of { happy_var_1 -> + happyIn265+ (happy_var_1+ )}++happyReduce_673 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_673 = happyMonadReduce 3# 249# happyReduction_673+happyReduction_673 (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 happyOut305 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn265 r))++happyReduce_674 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_674 = happySpecReduce_1 249# happyReduction_674+happyReduction_674 happy_x_1+ = case happyOut268 happy_x_1 of { happy_var_1 -> + happyIn265+ (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))+ )}++happyReduce_675 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_675 = happySpecReduce_1 250# happyReduction_675+happyReduction_675 happy_x_1+ = case happyOut265 happy_x_1 of { happy_var_1 -> + happyIn266+ (sL1 happy_var_1 [happy_var_1]+ )}++happyReduce_676 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_676 = happyMonadReduce 3# 250# happyReduction_676+happyReduction_676 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOut265 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut266 happy_x_3 of { happy_var_3 -> + ( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+ return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})+ ) (\r -> happyReturn (happyIn266 r))++happyReduce_677 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_677 = happyMonadReduce 2# 251# happyReduction_677+happyReduction_677 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 unitDataCon) [mop happy_var_1,mcp happy_var_2])}})+ ) (\r -> happyReturn (happyIn267 r))++happyReduce_678 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_678 = happyMonadReduce 3# 251# happyReduction_678+happyReduction_678 (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 happyOut309 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Boxed (snd happy_var_2 + 1))+ (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})+ ) (\r -> happyReturn (happyIn267 r))++happyReduce_679 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_679 = happyMonadReduce 2# 251# happyReduction_679+happyReduction_679 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ unboxedUnitDataCon) [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn267 r))++happyReduce_680 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_680 = happyMonadReduce 3# 251# happyReduction_680+happyReduction_680 (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 happyOut309 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Unboxed (snd happy_var_2 + 1))+ (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})+ ) (\r -> happyReturn (happyIn267 r))++happyReduce_681 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_681 = happySpecReduce_1 252# happyReduction_681+happyReduction_681 happy_x_1+ = case happyOut267 happy_x_1 of { happy_var_1 -> + happyIn268+ (happy_var_1+ )}++happyReduce_682 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_682 = happyMonadReduce 2# 252# happyReduction_682+happyReduction_682 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 nilDataCon) [mos happy_var_1,mcs happy_var_2])}})+ ) (\r -> happyReturn (happyIn268 r))++happyReduce_683 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_683 = happySpecReduce_1 253# happyReduction_683+happyReduction_683 happy_x_1+ = case happyOut305 happy_x_1 of { happy_var_1 -> + happyIn269+ (happy_var_1+ )}++happyReduce_684 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_684 = happyMonadReduce 3# 253# happyReduction_684+happyReduction_684 (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 happyOut303 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn269 r))++happyReduce_685 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_685 = happySpecReduce_1 254# happyReduction_685+happyReduction_685 happy_x_1+ = case happyOut304 happy_x_1 of { happy_var_1 -> + happyIn270+ (happy_var_1+ )}++happyReduce_686 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_686 = happyMonadReduce 3# 254# happyReduction_686+happyReduction_686 (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 happyOut302 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn270 r))++happyReduce_687 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_687 = happySpecReduce_1 255# happyReduction_687+happyReduction_687 happy_x_1+ = case happyOut272 happy_x_1 of { happy_var_1 -> + happyIn271+ (happy_var_1+ )}++happyReduce_688 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_688 = happyMonadReduce 2# 255# happyReduction_688+happyReduction_688 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ getRdrName unitTyCon)+ [mop happy_var_1,mcp happy_var_2])}})+ ) (\r -> happyReturn (happyIn271 r))++happyReduce_689 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_689 = happyMonadReduce 2# 255# happyReduction_689+happyReduction_689 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ getRdrName unboxedUnitTyCon)+ [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn271 r))++happyReduce_690 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_690 = happySpecReduce_1 256# happyReduction_690+happyReduction_690 happy_x_1+ = case happyOut273 happy_x_1 of { happy_var_1 -> + happyIn272+ (happy_var_1+ )}++happyReduce_691 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_691 = happyMonadReduce 3# 256# happyReduction_691+happyReduction_691 (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 happyOut309 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Boxed+ (snd happy_var_2 + 1)))+ (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})+ ) (\r -> happyReturn (happyIn272 r))++happyReduce_692 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_692 = happyMonadReduce 3# 256# happyReduction_692+happyReduction_692 (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 happyOut309 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Unboxed+ (snd happy_var_2 + 1)))+ (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})+ ) (\r -> happyReturn (happyIn272 r))++happyReduce_693 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_693 = happyMonadReduce 3# 256# happyReduction_693+happyReduction_693 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)+ [mop happy_var_1,mu AnnRarrow happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn272 r))++happyReduce_694 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_694 = happyMonadReduce 2# 256# happyReduction_694+happyReduction_694 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ listTyCon_RDR) [mos happy_var_1,mcs happy_var_2])}})+ ) (\r -> happyReturn (happyIn272 r))++happyReduce_695 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_695 = happyMonadReduce 2# 256# happyReduction_695+happyReduction_695 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + ( ams (sLL happy_var_1 happy_var_2 $ parrTyCon_RDR) [mo happy_var_1,mc happy_var_2])}})+ ) (\r -> happyReturn (happyIn272 r))++happyReduce_696 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_696 = happyMonadReduce 3# 256# happyReduction_696+happyReduction_696 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ getRdrName eqPrimTyCon)+ [mop happy_var_1,mj AnnTildehsh happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn272 r))++happyReduce_697 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_697 = happySpecReduce_1 257# happyReduction_697+happyReduction_697 happy_x_1+ = case happyOut276 happy_x_1 of { happy_var_1 -> + happyIn273+ (happy_var_1+ )}++happyReduce_698 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_698 = happyMonadReduce 3# 257# happyReduction_698+happyReduction_698 (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 happyOut279 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn273 r))++happyReduce_699 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_699 = happyMonadReduce 3# 257# happyReduction_699+happyReduction_699 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ eqTyCon_RDR)+ [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn273 r))++happyReduce_700 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_700 = happySpecReduce_1 258# happyReduction_700+happyReduction_700 happy_x_1+ = case happyOut276 happy_x_1 of { happy_var_1 -> + happyIn274+ (happy_var_1+ )}++happyReduce_701 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_701 = happyMonadReduce 3# 258# happyReduction_701+happyReduction_701 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( let name = sL1 happy_var_2 $! mkQual tcClsName (getQCONSYM happy_var_2)+ in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn274 r))++happyReduce_702 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_702 = happyMonadReduce 3# 258# happyReduction_702+happyReduction_702 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( let name = sL1 happy_var_2 $! mkUnqual tcClsName (getCONSYM happy_var_2)+ in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn274 r))++happyReduce_703 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_703 = happyMonadReduce 3# 258# happyReduction_703+happyReduction_703 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( let name = sL1 happy_var_2 $! consDataCon_RDR+ in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn274 r))++happyReduce_704 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_704 = happyMonadReduce 3# 258# happyReduction_704+happyReduction_704 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 $ eqTyCon_RDR) [mop happy_var_1,mj AnnTilde happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn274 r))++happyReduce_705 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_705 = happySpecReduce_1 259# happyReduction_705+happyReduction_705 happy_x_1+ = case happyOut279 happy_x_1 of { happy_var_1 -> + happyIn275+ (happy_var_1+ )}++happyReduce_706 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_706 = happyMonadReduce 3# 259# happyReduction_706+happyReduction_706 (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 happyOut276 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn275 r))++happyReduce_707 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_707 = happySpecReduce_1 260# happyReduction_707+happyReduction_707 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn276+ (sL1 happy_var_1 $! mkQual tcClsName (getQCONID happy_var_1)+ )}++happyReduce_708 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_708 = happySpecReduce_1 260# happyReduction_708+happyReduction_708 happy_x_1+ = case happyOut278 happy_x_1 of { happy_var_1 -> + happyIn276+ (happy_var_1+ )}++happyReduce_709 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_709 = happySpecReduce_1 261# happyReduction_709+happyReduction_709 happy_x_1+ = case happyOut276 happy_x_1 of { happy_var_1 -> + happyIn277+ (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)+ )}++happyReduce_710 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_710 = happySpecReduce_2 261# happyReduction_710+happyReduction_710 happy_x_2+ happy_x_1+ = case happyOut276 happy_x_1 of { happy_var_1 -> + case happyOut313 happy_x_2 of { happy_var_2 -> + happyIn277+ (sLL happy_var_1 happy_var_2 (HsDocTy (sL1 happy_var_1 (HsTyVar NotPromoted happy_var_1)) happy_var_2)+ )}}++happyReduce_711 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_711 = happySpecReduce_1 262# happyReduction_711+happyReduction_711 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn278+ (sL1 happy_var_1 $! mkUnqual tcClsName (getCONID happy_var_1)+ )}++happyReduce_712 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_712 = happySpecReduce_1 263# happyReduction_712+happyReduction_712 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn279+ (sL1 happy_var_1 $! mkQual tcClsName (getQCONSYM happy_var_1)+ )}++happyReduce_713 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_713 = happySpecReduce_1 263# happyReduction_713+happyReduction_713 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn279+ (sL1 happy_var_1 $! mkQual tcClsName (getQVARSYM happy_var_1)+ )}++happyReduce_714 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_714 = happySpecReduce_1 263# happyReduction_714+happyReduction_714 happy_x_1+ = case happyOut280 happy_x_1 of { happy_var_1 -> + happyIn279+ (happy_var_1+ )}++happyReduce_715 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_715 = happySpecReduce_1 264# happyReduction_715+happyReduction_715 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn280+ (sL1 happy_var_1 $! mkUnqual tcClsName (getCONSYM happy_var_1)+ )}++happyReduce_716 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_716 = happySpecReduce_1 264# happyReduction_716+happyReduction_716 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn280+ (sL1 happy_var_1 $! mkUnqual tcClsName (getVARSYM happy_var_1)+ )}++happyReduce_717 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_717 = happySpecReduce_1 264# happyReduction_717+happyReduction_717 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn280+ (sL1 happy_var_1 $! consDataCon_RDR+ )}++happyReduce_718 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_718 = happySpecReduce_1 264# happyReduction_718+happyReduction_718 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn280+ (sL1 happy_var_1 $! mkUnqual tcClsName (fsLit "-")+ )}++happyReduce_719 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_719 = happySpecReduce_1 265# happyReduction_719+happyReduction_719 happy_x_1+ = case happyOut282 happy_x_1 of { happy_var_1 -> + happyIn281+ (happy_var_1+ )}++happyReduce_720 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_720 = happySpecReduce_1 265# happyReduction_720+happyReduction_720 happy_x_1+ = case happyOut269 happy_x_1 of { happy_var_1 -> + happyIn281+ (happy_var_1+ )}++happyReduce_721 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_721 = happySpecReduce_1 266# happyReduction_721+happyReduction_721 happy_x_1+ = case happyOut298 happy_x_1 of { happy_var_1 -> + happyIn282+ (happy_var_1+ )}++happyReduce_722 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_722 = happyMonadReduce 3# 266# happyReduction_722+happyReduction_722 (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 happyOut294 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn282 r))++happyReduce_723 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_723 = happySpecReduce_1 267# happyReduction_723+happyReduction_723 happy_x_1+ = case happyOut286 happy_x_1 of { happy_var_1 -> + happyIn283+ (sL1 happy_var_1 $ HsVar happy_var_1+ )}++happyReduce_724 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_724 = happySpecReduce_1 267# happyReduction_724+happyReduction_724 happy_x_1+ = case happyOut270 happy_x_1 of { happy_var_1 -> + happyIn283+ (sL1 happy_var_1 $ HsVar happy_var_1+ )}++happyReduce_725 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_725 = happySpecReduce_1 267# happyReduction_725+happyReduction_725 happy_x_1+ = case happyOut285 happy_x_1 of { happy_var_1 -> + happyIn283+ (happy_var_1+ )}++happyReduce_726 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_726 = happySpecReduce_1 268# happyReduction_726+happyReduction_726 happy_x_1+ = case happyOut287 happy_x_1 of { happy_var_1 -> + happyIn284+ (sL1 happy_var_1 $ HsVar happy_var_1+ )}++happyReduce_727 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_727 = happySpecReduce_1 268# happyReduction_727+happyReduction_727 happy_x_1+ = case happyOut270 happy_x_1 of { happy_var_1 -> + happyIn284+ (sL1 happy_var_1 $ HsVar happy_var_1+ )}++happyReduce_728 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_728 = happySpecReduce_1 268# happyReduction_728+happyReduction_728 happy_x_1+ = case happyOut285 happy_x_1 of { happy_var_1 -> + happyIn284+ (happy_var_1+ )}++happyReduce_729 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_729 = happyMonadReduce 3# 269# happyReduction_729+happyReduction_729 (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 happyOutTok happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 EWildPat)+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn285 r))++happyReduce_730 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_730 = happySpecReduce_1 270# happyReduction_730+happyReduction_730 happy_x_1+ = case happyOut295 happy_x_1 of { happy_var_1 -> + happyIn286+ (happy_var_1+ )}++happyReduce_731 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_731 = happyMonadReduce 3# 270# happyReduction_731+happyReduction_731 (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 happyOut293 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn286 r))++happyReduce_732 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_732 = happySpecReduce_1 271# happyReduction_732+happyReduction_732 happy_x_1+ = case happyOut296 happy_x_1 of { happy_var_1 -> + happyIn287+ (happy_var_1+ )}++happyReduce_733 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_733 = happyMonadReduce 3# 271# happyReduction_733+happyReduction_733 (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 happyOut293 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn287 r))++happyReduce_734 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_734 = happySpecReduce_1 272# happyReduction_734+happyReduction_734 happy_x_1+ = case happyOut290 happy_x_1 of { happy_var_1 -> + happyIn288+ (happy_var_1+ )}++happyReduce_735 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_735 = happyMonadReduce 3# 273# happyReduction_735+happyReduction_735 (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 happyOut290 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+ ,mj AnnBackquote happy_var_3])}}})+ ) (\r -> happyReturn (happyIn289 r))++happyReduce_736 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_736 = happyMonadReduce 1# 273# happyReduction_736+happyReduction_736 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( hintExplicitForall' (getLoc happy_var_1))})+ ) (\r -> happyReturn (happyIn289 r))++happyReduce_737 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_737 = happySpecReduce_1 274# happyReduction_737+happyReduction_737 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn290+ (sL1 happy_var_1 $! mkUnqual tvName (getVARID happy_var_1)+ )}++happyReduce_738 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_738 = happySpecReduce_1 274# happyReduction_738+happyReduction_738 happy_x_1+ = case happyOut300 happy_x_1 of { happy_var_1 -> + happyIn290+ (sL1 happy_var_1 $! mkUnqual tvName (unLoc happy_var_1)+ )}++happyReduce_739 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_739 = happySpecReduce_1 274# happyReduction_739+happyReduction_739 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn290+ (sL1 happy_var_1 $! mkUnqual tvName (fsLit "unsafe")+ )}++happyReduce_740 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_740 = happySpecReduce_1 274# happyReduction_740+happyReduction_740 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn290+ (sL1 happy_var_1 $! mkUnqual tvName (fsLit "safe")+ )}++happyReduce_741 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_741 = happySpecReduce_1 274# happyReduction_741+happyReduction_741 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn290+ (sL1 happy_var_1 $! mkUnqual tvName (fsLit "interruptible")+ )}++happyReduce_742 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_742 = happySpecReduce_1 275# happyReduction_742+happyReduction_742 happy_x_1+ = case happyOut294 happy_x_1 of { happy_var_1 -> + happyIn291+ (happy_var_1+ )}++happyReduce_743 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_743 = happyMonadReduce 3# 275# happyReduction_743+happyReduction_743 (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 happyOut298 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn291 r))++happyReduce_744 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_744 = happySpecReduce_1 276# happyReduction_744+happyReduction_744 happy_x_1+ = case happyOut293 happy_x_1 of { happy_var_1 -> + happyIn292+ (happy_var_1+ )}++happyReduce_745 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_745 = happyMonadReduce 3# 276# happyReduction_745+happyReduction_745 (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 happyOut298 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn292 r))++happyReduce_746 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_746 = happyMonadReduce 3# 276# happyReduction_746+happyReduction_746 (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 happyOut297 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+ [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+ ) (\r -> happyReturn (happyIn292 r))++happyReduce_747 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_747 = happySpecReduce_1 277# happyReduction_747+happyReduction_747 happy_x_1+ = case happyOut294 happy_x_1 of { happy_var_1 -> + happyIn293+ (happy_var_1+ )}++happyReduce_748 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_748 = happySpecReduce_1 277# happyReduction_748+happyReduction_748 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn293+ (sL1 happy_var_1 $! mkQual varName (getQVARID happy_var_1)+ )}++happyReduce_749 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_749 = happySpecReduce_1 278# happyReduction_749+happyReduction_749 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (getVARID happy_var_1)+ )}++happyReduce_750 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_750 = happySpecReduce_1 278# happyReduction_750+happyReduction_750 happy_x_1+ = case happyOut300 happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (unLoc happy_var_1)+ )}++happyReduce_751 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_751 = happySpecReduce_1 278# happyReduction_751+happyReduction_751 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (fsLit "unsafe")+ )}++happyReduce_752 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_752 = happySpecReduce_1 278# happyReduction_752+happyReduction_752 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (fsLit "safe")+ )}++happyReduce_753 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_753 = happySpecReduce_1 278# happyReduction_753+happyReduction_753 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (fsLit "interruptible")+ )}++happyReduce_754 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_754 = happySpecReduce_1 278# happyReduction_754+happyReduction_754 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (fsLit "forall")+ )}++happyReduce_755 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_755 = happySpecReduce_1 278# happyReduction_755+happyReduction_755 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (fsLit "family")+ )}++happyReduce_756 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_756 = happySpecReduce_1 278# happyReduction_756+happyReduction_756 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn294+ (sL1 happy_var_1 $! mkUnqual varName (fsLit "role")+ )}++happyReduce_757 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_757 = happySpecReduce_1 279# happyReduction_757+happyReduction_757 happy_x_1+ = case happyOut298 happy_x_1 of { happy_var_1 -> + happyIn295+ (happy_var_1+ )}++happyReduce_758 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_758 = happySpecReduce_1 279# happyReduction_758+happyReduction_758 happy_x_1+ = case happyOut297 happy_x_1 of { happy_var_1 -> + happyIn295+ (happy_var_1+ )}++happyReduce_759 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_759 = happySpecReduce_1 280# happyReduction_759+happyReduction_759 happy_x_1+ = case happyOut299 happy_x_1 of { happy_var_1 -> + happyIn296+ (happy_var_1+ )}++happyReduce_760 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_760 = happySpecReduce_1 280# happyReduction_760+happyReduction_760 happy_x_1+ = case happyOut297 happy_x_1 of { happy_var_1 -> + happyIn296+ (happy_var_1+ )}++happyReduce_761 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_761 = happySpecReduce_1 281# happyReduction_761+happyReduction_761 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn297+ (sL1 happy_var_1 $ mkQual varName (getQVARSYM happy_var_1)+ )}++happyReduce_762 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_762 = happySpecReduce_1 282# happyReduction_762+happyReduction_762 happy_x_1+ = case happyOut299 happy_x_1 of { happy_var_1 -> + happyIn298+ (happy_var_1+ )}++happyReduce_763 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_763 = happySpecReduce_1 282# happyReduction_763+happyReduction_763 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn298+ (sL1 happy_var_1 $ mkUnqual varName (fsLit "-")+ )}++happyReduce_764 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_764 = happySpecReduce_1 283# happyReduction_764+happyReduction_764 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn299+ (sL1 happy_var_1 $ mkUnqual varName (getVARSYM happy_var_1)+ )}++happyReduce_765 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_765 = happySpecReduce_1 283# happyReduction_765+happyReduction_765 happy_x_1+ = case happyOut301 happy_x_1 of { happy_var_1 -> + happyIn299+ (sL1 happy_var_1 $ mkUnqual varName (unLoc happy_var_1)+ )}++happyReduce_766 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_766 = happySpecReduce_1 284# happyReduction_766+happyReduction_766 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "as")+ )}++happyReduce_767 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_767 = happySpecReduce_1 284# happyReduction_767+happyReduction_767 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "qualified")+ )}++happyReduce_768 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_768 = happySpecReduce_1 284# happyReduction_768+happyReduction_768 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "hiding")+ )}++happyReduce_769 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_769 = happySpecReduce_1 284# happyReduction_769+happyReduction_769 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "export")+ )}++happyReduce_770 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_770 = happySpecReduce_1 284# happyReduction_770+happyReduction_770 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "label")+ )}++happyReduce_771 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_771 = happySpecReduce_1 284# happyReduction_771+happyReduction_771 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "dynamic")+ )}++happyReduce_772 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_772 = happySpecReduce_1 284# happyReduction_772+happyReduction_772 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "stdcall")+ )}++happyReduce_773 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_773 = happySpecReduce_1 284# happyReduction_773+happyReduction_773 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "ccall")+ )}++happyReduce_774 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_774 = happySpecReduce_1 284# happyReduction_774+happyReduction_774 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "capi")+ )}++happyReduce_775 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_775 = happySpecReduce_1 284# happyReduction_775+happyReduction_775 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "prim")+ )}++happyReduce_776 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_776 = happySpecReduce_1 284# happyReduction_776+happyReduction_776 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "javascript")+ )}++happyReduce_777 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_777 = happySpecReduce_1 284# happyReduction_777+happyReduction_777 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "group")+ )}++happyReduce_778 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_778 = happySpecReduce_1 284# happyReduction_778+happyReduction_778 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "stock")+ )}++happyReduce_779 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_779 = happySpecReduce_1 284# happyReduction_779+happyReduction_779 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "anyclass")+ )}++happyReduce_780 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_780 = happySpecReduce_1 284# happyReduction_780+happyReduction_780 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "unit")+ )}++happyReduce_781 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_781 = happySpecReduce_1 284# happyReduction_781+happyReduction_781 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "dependency")+ )}++happyReduce_782 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_782 = happySpecReduce_1 284# happyReduction_782+happyReduction_782 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn300+ (sL1 happy_var_1 (fsLit "signature")+ )}++happyReduce_783 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_783 = happyMonadReduce 1# 285# happyReduction_783+happyReduction_783 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( ams (sL1 happy_var_1 (fsLit "!")) [mj AnnBang happy_var_1])})+ ) (\r -> happyReturn (happyIn301 r))++happyReduce_784 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_784 = happySpecReduce_1 285# happyReduction_784+happyReduction_784 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn301+ (sL1 happy_var_1 (fsLit ".")+ )}++happyReduce_785 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_785 = happySpecReduce_1 286# happyReduction_785+happyReduction_785 happy_x_1+ = case happyOut303 happy_x_1 of { happy_var_1 -> + happyIn302+ (happy_var_1+ )}++happyReduce_786 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_786 = happySpecReduce_1 286# happyReduction_786+happyReduction_786 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn302+ (sL1 happy_var_1 $! mkQual dataName (getQCONID happy_var_1)+ )}++happyReduce_787 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_787 = happySpecReduce_1 287# happyReduction_787+happyReduction_787 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn303+ (sL1 happy_var_1 $ mkUnqual dataName (getCONID happy_var_1)+ )}++happyReduce_788 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_788 = happySpecReduce_1 288# happyReduction_788+happyReduction_788 happy_x_1+ = case happyOut305 happy_x_1 of { happy_var_1 -> + happyIn304+ (happy_var_1+ )}++happyReduce_789 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_789 = happySpecReduce_1 288# happyReduction_789+happyReduction_789 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn304+ (sL1 happy_var_1 $ mkQual dataName (getQCONSYM happy_var_1)+ )}++happyReduce_790 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_790 = happySpecReduce_1 289# happyReduction_790+happyReduction_790 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn305+ (sL1 happy_var_1 $ mkUnqual dataName (getCONSYM happy_var_1)+ )}++happyReduce_791 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_791 = happySpecReduce_1 289# happyReduction_791+happyReduction_791 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn305+ (sL1 happy_var_1 $ consDataCon_RDR+ )}++happyReduce_792 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_792 = happySpecReduce_1 290# happyReduction_792+happyReduction_792 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsChar (sst $ getCHARs happy_var_1) $ getCHAR happy_var_1+ )}++happyReduce_793 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_793 = happySpecReduce_1 290# happyReduction_793+happyReduction_793 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsString (sst $ getSTRINGs happy_var_1)+ $ getSTRING happy_var_1+ )}++happyReduce_794 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_794 = happySpecReduce_1 290# happyReduction_794+happyReduction_794 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsIntPrim (sst $ getPRIMINTEGERs happy_var_1)+ $ getPRIMINTEGER happy_var_1+ )}++happyReduce_795 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_795 = happySpecReduce_1 290# happyReduction_795+happyReduction_795 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsWordPrim (sst $ getPRIMWORDs happy_var_1)+ $ getPRIMWORD happy_var_1+ )}++happyReduce_796 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_796 = happySpecReduce_1 290# happyReduction_796+happyReduction_796 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsCharPrim (sst $ getPRIMCHARs happy_var_1)+ $ getPRIMCHAR happy_var_1+ )}++happyReduce_797 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_797 = happySpecReduce_1 290# happyReduction_797+happyReduction_797 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsStringPrim (sst $ getPRIMSTRINGs happy_var_1)+ $ getPRIMSTRING happy_var_1+ )}++happyReduce_798 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_798 = happySpecReduce_1 290# happyReduction_798+happyReduction_798 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsFloatPrim def $ getPRIMFLOAT happy_var_1+ )}++happyReduce_799 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_799 = happySpecReduce_1 290# happyReduction_799+happyReduction_799 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn306+ (sL1 happy_var_1 $ HsDoublePrim def $ getPRIMDOUBLE happy_var_1+ )}++happyReduce_800 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_800 = happySpecReduce_1 291# happyReduction_800+happyReduction_800 happy_x_1+ = happyIn307+ (()+ )++happyReduce_801 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_801 = happyMonadReduce 1# 291# happyReduction_801+happyReduction_801 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((( popContext))+ ) (\r -> happyReturn (happyIn307 r))++happyReduce_802 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_802 = happySpecReduce_1 292# happyReduction_802+happyReduction_802 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn308+ (sL1 happy_var_1 $ mkModuleNameFS (getCONID happy_var_1)+ )}++happyReduce_803 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_803 = happySpecReduce_1 292# happyReduction_803+happyReduction_803 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn308+ (sL1 happy_var_1 $ let (mod,c) = getQCONID happy_var_1 in+ mkModuleNameFS+ (mkFastString+ (unpackFS mod ++ '.':unpackFS c))+ )}++happyReduce_804 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_804 = happySpecReduce_2 293# happyReduction_804+happyReduction_804 happy_x_2+ happy_x_1+ = case happyOut309 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn309+ (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)+ )}}++happyReduce_805 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_805 = happySpecReduce_1 293# happyReduction_805+happyReduction_805 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn309+ (([gl happy_var_1],1)+ )}++happyReduce_806 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_806 = happySpecReduce_1 294# happyReduction_806+happyReduction_806 happy_x_1+ = case happyOut311 happy_x_1 of { happy_var_1 -> + happyIn310+ (happy_var_1+ )}++happyReduce_807 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_807 = happySpecReduce_0 294# happyReduction_807+happyReduction_807 = happyIn310+ (([], 0)+ )++happyReduce_808 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_808 = happySpecReduce_2 295# happyReduction_808+happyReduction_808 happy_x_2+ happy_x_1+ = case happyOut311 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn311+ (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)+ )}}++happyReduce_809 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_809 = happySpecReduce_1 295# happyReduction_809+happyReduction_809 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn311+ (([gl happy_var_1],1)+ )}++happyReduce_810 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_810 = happyMonadReduce 1# 296# happyReduction_810+happyReduction_810 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( return (sL1 happy_var_1 (HsDocString (mkFastString (getDOCNEXT happy_var_1)))))})+ ) (\r -> happyReturn (happyIn312 r))++happyReduce_811 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_811 = happyMonadReduce 1# 297# happyReduction_811+happyReduction_811 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( return (sL1 happy_var_1 (HsDocString (mkFastString (getDOCPREV happy_var_1)))))})+ ) (\r -> happyReturn (happyIn313 r))++happyReduce_812 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_812 = happyMonadReduce 1# 298# happyReduction_812+happyReduction_812 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + (+ let string = getDOCNAMED happy_var_1+ (name, rest) = break isSpace string+ in return (sL1 happy_var_1 (name, HsDocString (mkFastString rest))))})+ ) (\r -> happyReturn (happyIn314 r))++happyReduce_813 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_813 = happyMonadReduce 1# 299# happyReduction_813+happyReduction_813 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( let (n, doc) = getDOCSECTION happy_var_1 in+ return (sL1 happy_var_1 (n, HsDocString (mkFastString doc))))})+ ) (\r -> happyReturn (happyIn315 r))++happyReduce_814 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_814 = happyMonadReduce 1# 300# happyReduction_814+happyReduction_814 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> + ( let string = getDOCNEXT happy_var_1 in+ return (Just (sL1 happy_var_1 (HsDocString (mkFastString string)))))})+ ) (\r -> happyReturn (happyIn316 r))++happyReduce_815 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_815 = happySpecReduce_1 301# happyReduction_815+happyReduction_815 happy_x_1+ = case happyOut313 happy_x_1 of { happy_var_1 -> + happyIn317+ (Just happy_var_1+ )}++happyReduce_816 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_816 = happySpecReduce_0 301# happyReduction_816+happyReduction_816 = happyIn317+ (Nothing+ )++happyReduce_817 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_817 = happySpecReduce_1 302# happyReduction_817+happyReduction_817 happy_x_1+ = case happyOut312 happy_x_1 of { happy_var_1 -> + happyIn318+ (Just happy_var_1+ )}++happyReduce_818 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_818 = happySpecReduce_0 302# happyReduction_818+happyReduction_818 = happyIn318+ (Nothing+ )++happyNewToken action sts stk+ = (lexer True)(\tk -> + let cont i = happyDoAction i tk action sts stk in+ case tk of {+ L _ ITeof -> happyDoAction 155# tk action sts stk;+ L _ ITunderscore -> cont 1#;+ L _ ITas -> cont 2#;+ L _ ITcase -> cont 3#;+ L _ ITclass -> cont 4#;+ L _ ITdata -> cont 5#;+ L _ ITdefault -> cont 6#;+ L _ ITderiving -> cont 7#;+ L _ ITdo -> cont 8#;+ L _ ITelse -> cont 9#;+ L _ IThiding -> cont 10#;+ L _ ITif -> cont 11#;+ L _ ITimport -> cont 12#;+ L _ ITin -> cont 13#;+ L _ ITinfix -> cont 14#;+ L _ ITinfixl -> cont 15#;+ L _ ITinfixr -> cont 16#;+ L _ ITinstance -> cont 17#;+ L _ ITlet -> cont 18#;+ L _ ITmodule -> cont 19#;+ L _ ITnewtype -> cont 20#;+ L _ ITof -> cont 21#;+ L _ ITqualified -> cont 22#;+ L _ ITthen -> cont 23#;+ L _ ITtype -> cont 24#;+ L _ ITwhere -> cont 25#;+ L _ (ITforall _) -> cont 26#;+ L _ ITforeign -> cont 27#;+ L _ ITexport -> cont 28#;+ L _ ITlabel -> cont 29#;+ L _ ITdynamic -> cont 30#;+ L _ ITsafe -> cont 31#;+ L _ ITinterruptible -> cont 32#;+ L _ ITunsafe -> cont 33#;+ L _ ITmdo -> cont 34#;+ L _ ITfamily -> cont 35#;+ L _ ITrole -> cont 36#;+ L _ ITstdcallconv -> cont 37#;+ L _ ITccallconv -> cont 38#;+ L _ ITcapiconv -> cont 39#;+ L _ ITprimcallconv -> cont 40#;+ L _ ITjavascriptcallconv -> cont 41#;+ L _ ITproc -> cont 42#;+ L _ ITrec -> cont 43#;+ L _ ITgroup -> cont 44#;+ L _ ITby -> cont 45#;+ L _ ITusing -> cont 46#;+ L _ ITpattern -> cont 47#;+ L _ ITstatic -> cont 48#;+ L _ ITstock -> cont 49#;+ L _ ITanyclass -> cont 50#;+ L _ ITunit -> cont 51#;+ L _ ITsignature -> cont 52#;+ L _ ITdependency -> cont 53#;+ L _ (ITinline_prag _ _ _) -> cont 54#;+ L _ (ITspec_prag _) -> cont 55#;+ L _ (ITspec_inline_prag _ _) -> cont 56#;+ L _ (ITsource_prag _) -> cont 57#;+ L _ (ITrules_prag _) -> cont 58#;+ L _ (ITcore_prag _) -> cont 59#;+ L _ (ITscc_prag _) -> cont 60#;+ L _ (ITgenerated_prag _) -> cont 61#;+ L _ (ITdeprecated_prag _) -> cont 62#;+ L _ (ITwarning_prag _) -> cont 63#;+ L _ (ITunpack_prag _) -> cont 64#;+ L _ (ITnounpack_prag _) -> cont 65#;+ L _ (ITann_prag _) -> cont 66#;+ L _ (ITvect_prag _) -> cont 67#;+ L _ (ITvect_scalar_prag _) -> cont 68#;+ L _ (ITnovect_prag _) -> cont 69#;+ L _ (ITminimal_prag _) -> cont 70#;+ L _ (ITctype _) -> cont 71#;+ L _ (IToverlapping_prag _) -> cont 72#;+ L _ (IToverlappable_prag _) -> cont 73#;+ L _ (IToverlaps_prag _) -> cont 74#;+ L _ (ITincoherent_prag _) -> cont 75#;+ L _ (ITcomplete_prag _) -> cont 76#;+ L _ ITclose_prag -> cont 77#;+ L _ ITdotdot -> cont 78#;+ L _ ITcolon -> cont 79#;+ L _ (ITdcolon _) -> cont 80#;+ L _ ITequal -> cont 81#;+ L _ ITlam -> cont 82#;+ L _ ITlcase -> cont 83#;+ L _ ITvbar -> cont 84#;+ L _ (ITlarrow _) -> cont 85#;+ L _ (ITrarrow _) -> cont 86#;+ L _ ITat -> cont 87#;+ L _ ITtilde -> cont 88#;+ L _ ITtildehsh -> cont 89#;+ L _ (ITdarrow _) -> cont 90#;+ L _ ITminus -> cont 91#;+ L _ ITbang -> cont 92#;+ L _ (ITlarrowtail _) -> cont 93#;+ L _ (ITrarrowtail _) -> cont 94#;+ L _ (ITLarrowtail _) -> cont 95#;+ L _ (ITRarrowtail _) -> cont 96#;+ L _ ITdot -> cont 97#;+ L _ ITtypeApp -> cont 98#;+ L _ ITocurly -> cont 99#;+ L _ ITccurly -> cont 100#;+ L _ ITvocurly -> cont 101#;+ L _ ITvccurly -> cont 102#;+ L _ ITobrack -> cont 103#;+ L _ ITcbrack -> cont 104#;+ L _ ITopabrack -> cont 105#;+ L _ ITcpabrack -> cont 106#;+ L _ IToparen -> cont 107#;+ L _ ITcparen -> cont 108#;+ L _ IToubxparen -> cont 109#;+ L _ ITcubxparen -> cont 110#;+ L _ (IToparenbar _) -> cont 111#;+ L _ (ITcparenbar _) -> cont 112#;+ L _ ITsemi -> cont 113#;+ L _ ITcomma -> cont 114#;+ L _ ITbackquote -> cont 115#;+ L _ ITsimpleQuote -> cont 116#;+ L _ (ITvarid _) -> cont 117#;+ L _ (ITconid _) -> cont 118#;+ L _ (ITvarsym _) -> cont 119#;+ L _ (ITconsym _) -> cont 120#;+ L _ (ITqvarid _) -> cont 121#;+ L _ (ITqconid _) -> cont 122#;+ L _ (ITqvarsym _) -> cont 123#;+ L _ (ITqconsym _) -> cont 124#;+ L _ (ITdupipvarid _) -> cont 125#;+ L _ (ITlabelvarid _) -> cont 126#;+ L _ (ITchar _ _) -> cont 127#;+ L _ (ITstring _ _) -> cont 128#;+ L _ (ITinteger _) -> cont 129#;+ L _ (ITrational _) -> cont 130#;+ L _ (ITprimchar _ _) -> cont 131#;+ L _ (ITprimstring _ _) -> cont 132#;+ L _ (ITprimint _ _) -> cont 133#;+ L _ (ITprimword _ _) -> cont 134#;+ L _ (ITprimfloat _) -> cont 135#;+ L _ (ITprimdouble _) -> cont 136#;+ L _ (ITdocCommentNext _) -> cont 137#;+ L _ (ITdocCommentPrev _) -> cont 138#;+ L _ (ITdocCommentNamed _) -> cont 139#;+ L _ (ITdocSection _ _) -> cont 140#;+ L _ (ITopenExpQuote _ _) -> cont 141#;+ L _ ITopenPatQuote -> cont 142#;+ L _ ITopenTypQuote -> cont 143#;+ L _ ITopenDecQuote -> cont 144#;+ L _ (ITcloseQuote _) -> cont 145#;+ L _ (ITopenTExpQuote _) -> cont 146#;+ L _ ITcloseTExpQuote -> cont 147#;+ L _ (ITidEscape _) -> cont 148#;+ L _ ITparenEscape -> cont 149#;+ L _ (ITidTyEscape _) -> cont 150#;+ L _ ITparenTyEscape -> cont 151#;+ L _ ITtyQuote -> cont 152#;+ L _ (ITquasiQuote _) -> cont 153#;+ L _ (ITqQuasiQuote _) -> cont 154#;+ _ -> happyError' (tk, [])+ })++happyError_ explist 155# tk = happyError' (tk, explist)+happyError_ explist _ tk = happyError' (tk, explist)++happyThen :: () => P a -> (a -> P b) -> P b+happyThen = (>>=)+happyReturn :: () => a -> P a+happyReturn = (return)+happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn )++happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )++happyDoAction :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )++happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn ))++happyThen1 :: () => P a -> (a -> P b) -> P b+happyThen1 = happyThen+happyReturn1 :: () => a -> P a+happyReturn1 = happyReturn+happyError' :: () => (((Located Token)), [String]) -> P a+happyError' tk = (\(tokens, explist) -> happyError) tk+parseModule = happySomeParser where+ happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut34 x))++parseSignature = happySomeParser where+ happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut33 x))++parseImport = happySomeParser where+ happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut64 x))++parseStatement = happySomeParser where+ happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut246 x))++parseDeclaration = happySomeParser where+ happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut77 x))++parseExpression = happySomeParser where+ happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut200 x))++parsePattern = happySomeParser where+ happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (happyOut239 x))++parseTypeSignature = happySomeParser where+ happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (happyOut196 x))++parseStmt = happySomeParser where+ happySomeParser = happyThen (happyParse 8#) (\x -> happyReturn (happyOut245 x))++parseIdentifier = happySomeParser where+ happySomeParser = happyThen (happyParse 9#) (\x -> happyReturn (happyOut16 x))++parseType = happySomeParser where+ happySomeParser = happyThen (happyParse 10#) (\x -> happyReturn (happyOut151 x))++parseBackpack = happySomeParser where+ happySomeParser = happyThen (happyParse 11#) (\x -> happyReturn (happyOut17 x))++parseHeader = happySomeParser where+ happySomeParser = happyThen (happyParse 12#) (\x -> happyReturn (happyOut43 x))++happySeq = happyDontSeq+++happyError :: P a+happyError = srcParseFail++getVARID (L _ (ITvarid x)) = x+getCONID (L _ (ITconid x)) = x+getVARSYM (L _ (ITvarsym x)) = x+getCONSYM (L _ (ITconsym x)) = x+getQVARID (L _ (ITqvarid x)) = x+getQCONID (L _ (ITqconid x)) = x+getQVARSYM (L _ (ITqvarsym x)) = x+getQCONSYM (L _ (ITqconsym x)) = x+getIPDUPVARID (L _ (ITdupipvarid x)) = x+getLABELVARID (L _ (ITlabelvarid x)) = x+getCHAR (L _ (ITchar _ x)) = x+getSTRING (L _ (ITstring _ x)) = x+getINTEGER (L _ (ITinteger x)) = x+getRATIONAL (L _ (ITrational x)) = x+getPRIMCHAR (L _ (ITprimchar _ x)) = x+getPRIMSTRING (L _ (ITprimstring _ x)) = x+getPRIMINTEGER (L _ (ITprimint _ x)) = x+getPRIMWORD (L _ (ITprimword _ x)) = x+getPRIMFLOAT (L _ (ITprimfloat x)) = x+getPRIMDOUBLE (L _ (ITprimdouble x)) = x+getTH_ID_SPLICE (L _ (ITidEscape x)) = x+getTH_ID_TY_SPLICE (L _ (ITidTyEscape x)) = x+getINLINE (L _ (ITinline_prag _ inl conl)) = (inl,conl)+getSPEC_INLINE (L _ (ITspec_inline_prag _ True)) = (Inline, FunLike)+getSPEC_INLINE (L _ (ITspec_inline_prag _ False)) = (NoInline,FunLike)+getCOMPLETE_PRAGs (L _ (ITcomplete_prag x)) = x++getDOCNEXT (L _ (ITdocCommentNext x)) = x+getDOCPREV (L _ (ITdocCommentPrev x)) = x+getDOCNAMED (L _ (ITdocCommentNamed x)) = x+getDOCSECTION (L _ (ITdocSection n x)) = (n, x)++getINTEGERs (L _ (ITinteger (IL src _ _))) = src+getCHARs (L _ (ITchar src _)) = src+getSTRINGs (L _ (ITstring src _)) = src+getPRIMCHARs (L _ (ITprimchar src _)) = src+getPRIMSTRINGs (L _ (ITprimstring src _)) = src+getPRIMINTEGERs (L _ (ITprimint src _)) = src+getPRIMWORDs (L _ (ITprimword src _)) = src++-- See Note [Pragma source text] in BasicTypes for the following+getINLINE_PRAGs (L _ (ITinline_prag src _ _)) = src+getSPEC_PRAGs (L _ (ITspec_prag src)) = src+getSPEC_INLINE_PRAGs (L _ (ITspec_inline_prag src _)) = src+getSOURCE_PRAGs (L _ (ITsource_prag src)) = src+getRULES_PRAGs (L _ (ITrules_prag src)) = src+getWARNING_PRAGs (L _ (ITwarning_prag src)) = src+getDEPRECATED_PRAGs (L _ (ITdeprecated_prag src)) = src+getSCC_PRAGs (L _ (ITscc_prag src)) = src+getGENERATED_PRAGs (L _ (ITgenerated_prag src)) = src+getCORE_PRAGs (L _ (ITcore_prag src)) = src+getUNPACK_PRAGs (L _ (ITunpack_prag src)) = src+getNOUNPACK_PRAGs (L _ (ITnounpack_prag src)) = src+getANN_PRAGs (L _ (ITann_prag src)) = src+getVECT_PRAGs (L _ (ITvect_prag src)) = src+getVECT_SCALAR_PRAGs (L _ (ITvect_scalar_prag src)) = src+getNOVECT_PRAGs (L _ (ITnovect_prag src)) = src+getMINIMAL_PRAGs (L _ (ITminimal_prag src)) = src+getOVERLAPPABLE_PRAGs (L _ (IToverlappable_prag src)) = src+getOVERLAPPING_PRAGs (L _ (IToverlapping_prag src)) = src+getOVERLAPS_PRAGs (L _ (IToverlaps_prag src)) = src+getINCOHERENT_PRAGs (L _ (ITincoherent_prag src)) = src+getCTYPEs (L _ (ITctype src)) = src++getStringLiteral l = StringLiteral (getSTRINGs l) (getSTRING l)++isUnicode :: Located Token -> Bool+isUnicode (L _ (ITforall iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITdarrow iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITdcolon iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITlarrow iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITrarrow iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITlarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITrarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITLarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITRarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (IToparenbar iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITcparenbar iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITopenExpQuote _ iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITcloseQuote iu)) = iu == UnicodeSyntax+isUnicode _ = False++hasE :: Located Token -> Bool+hasE (L _ (ITopenExpQuote HasE _)) = True+hasE (L _ (ITopenTExpQuote HasE)) = True+hasE _ = False++getSCC :: Located Token -> P FastString+getSCC lt = do let s = getSTRING lt+ err = "Spaces are not allowed in SCCs"+ -- We probably actually want to be more restrictive than this+ if ' ' `elem` unpackFS s+ then failSpanMsgP (getLoc lt) (text err)+ else return s++-- Utilities for combining source spans+comb2 :: Located a -> Located b -> SrcSpan+comb2 a b = a `seq` b `seq` combineLocs a b++comb3 :: Located a -> Located b -> Located c -> SrcSpan+comb3 a b c = a `seq` b `seq` c `seq`+ combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLoc c))++comb4 :: Located a -> Located b -> Located c -> Located d -> SrcSpan+comb4 a b c d = a `seq` b `seq` c `seq` d `seq`+ (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $+ combineSrcSpans (getLoc c) (getLoc d))++-- strict constructor version:+{-# INLINE sL #-}+sL :: SrcSpan -> a -> Located a+sL span a = span `seq` a `seq` L span a++-- See Note [Adding location info] for how these utility functions are used++-- replaced last 3 CPP macros in this file+{-# INLINE sL0 #-}+sL0 :: a -> Located a+sL0 = L noSrcSpan -- #define L0 L noSrcSpan++{-# INLINE sL1 #-}+sL1 :: Located a -> b -> Located b+sL1 x = sL (getLoc x) -- #define sL1 sL (getLoc $1)++{-# INLINE sLL #-}+sLL :: Located a -> Located b -> c -> Located c+sLL x y = sL (comb2 x y) -- #define LL sL (comb2 $1 $>)++{- Note [Adding location info]+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~++This is done using the three functions below, sL0, sL1+and sLL. Note that these functions were mechanically+converted from the three macros that used to exist before,+namely L0, L1 and LL.++They each add a SrcSpan to their argument.++ sL0 adds 'noSrcSpan', used for empty productions+ -- This doesn't seem to work anymore -=chak++ sL1 for a production with a single token on the lhs. Grabs the SrcSpan+ from that token.++ sLL for a production with >1 token on the lhs. Makes up a SrcSpan from+ the first and last tokens.++These suffice for the majority of cases. However, we must be+especially careful with empty productions: sLL won't work if the first+or last token on the lhs can represent an empty span. In these cases,+we have to calculate the span using more of the tokens from the lhs, eg.++ | 'newtype' tycl_hdr '=' newconstr deriving+ { L (comb3 $1 $4 $5)+ (mkTyData NewType (unLoc $2) $4 (unLoc $5)) }++We provide comb3 and comb4 functions which are useful in such cases.++Be careful: there's no checking that you actually got this right, the+only symptom will be that the SrcSpans of your syntax will be+incorrect.++-}++-- Make a source location for the file. We're a bit lazy here and just+-- make a point SrcSpan at line 1, column 0. Strictly speaking we should+-- try to find the span of the whole file (ToDo).+fileSrcSpan :: P SrcSpan+fileSrcSpan = do+ l <- getSrcLoc;+ let loc = mkSrcLoc (srcLocFile l) 1 1;+ return (mkSrcSpan loc loc)++-- Hint about the MultiWayIf extension+hintMultiWayIf :: SrcSpan -> P ()+hintMultiWayIf span = do+ mwiEnabled <- liftM ((LangExt.MultiWayIf `extopt`) . options) getPState+ unless mwiEnabled $ parseErrorSDoc span $+ text "Multi-way if-expressions need MultiWayIf turned on"++-- Hint about if usage for beginners+hintIf :: SrcSpan -> String -> P (LHsExpr GhcPs)+hintIf span msg = do+ mwiEnabled <- liftM ((LangExt.MultiWayIf `extopt`) . options) getPState+ if mwiEnabled+ then parseErrorSDoc span $ text $ "parse error in if statement"+ else parseErrorSDoc span $ text $ "parse error in if statement: "++msg++-- Hint about explicit-forall, assuming UnicodeSyntax is on+hintExplicitForall :: SrcSpan -> P ()+hintExplicitForall span = do+ forall <- extension explicitForallEnabled+ rulePrag <- extension inRulePrag+ unless (forall || rulePrag) $ parseErrorSDoc span $ vcat+ [ text "Illegal symbol '\x2200' in type" -- U+2200 FOR ALL+ , text "Perhaps you intended to use RankNTypes or a similar language"+ , text "extension to enable explicit-forall syntax: \x2200 <tvs>. <type>"+ ]++-- Hint about explicit-forall, assuming UnicodeSyntax is off+hintExplicitForall' :: SrcSpan -> P (GenLocated SrcSpan RdrName)+hintExplicitForall' span = do+ forall <- extension explicitForallEnabled+ let illegalDot = "Illegal symbol '.' in type"+ if forall+ then parseErrorSDoc span $ vcat+ [ text illegalDot+ , text "Perhaps you meant to write 'forall <tvs>. <type>'?"+ ]+ else parseErrorSDoc span $ vcat+ [ text illegalDot+ , text "Perhaps you intended to use RankNTypes or a similar language"+ , text "extension to enable explicit-forall syntax: forall <tvs>. <type>"+ ]++{-+%************************************************************************+%* *+ Helper functions for generating annotations in the parser+%* *+%************************************************************************++For the general principles of the following routines, see Note [Api annotations]+in ApiAnnotation.hs++-}++-- |Construct an AddAnn from the annotation keyword and the location+-- of the keyword itself+mj :: AnnKeywordId -> Located e -> AddAnn+mj a l s = addAnnotation s a (gl l)++-- |Construct an AddAnn from the annotation keyword and the Located Token. If+-- the token has a unicode equivalent and this has been used, provide the+-- unicode variant of the annotation.+mu :: AnnKeywordId -> Located Token -> AddAnn+mu a lt@(L l t) = (\s -> addAnnotation s (toUnicodeAnn a lt) l)++-- | If the 'Token' is using its unicode variant return the unicode variant of+-- the annotation+toUnicodeAnn :: AnnKeywordId -> Located Token -> AnnKeywordId+toUnicodeAnn a t = if isUnicode t then unicodeAnn a else a++gl = getLoc++-- |Add an annotation to the located element, and return the located+-- element as a pass through+aa :: Located a -> (AnnKeywordId,Located c) -> P (Located a)+aa a@(L l _) (b,s) = addAnnotation l b (gl s) >> return a++-- |Add an annotation to a located element resulting from a monadic action+am :: P (Located a) -> (AnnKeywordId, Located b) -> P (Located a)+am a (b,s) = do+ av@(L l _) <- a+ addAnnotation l b (gl s)+ return av++-- | Add a list of AddAnns to the given AST element. For example,+-- the parsing rule for @let@ looks like:+--+-- @+-- | 'let' binds 'in' exp {% ams (sLL $1 $> $ HsLet (snd $ unLoc $2) $4)+-- (mj AnnLet $1:mj AnnIn $3+-- :(fst $ unLoc $2)) }+-- @+--+-- This adds an AnnLet annotation for @let@, an AnnIn for @in@, as well+-- as any annotations that may arise in the binds. This will include open+-- and closing braces if they are used to delimit the let expressions.+--+ams :: Located a -> [AddAnn] -> P (Located a)+ams a@(L l _) bs = addAnnsAt l bs >> return a++-- |Add all [AddAnn] to an AST element wrapped in a Just+aljs :: Located (Maybe a) -> [AddAnn] -> P (Located (Maybe a))+aljs a@(L l _) bs = addAnnsAt l bs >> return a++-- |Add all [AddAnn] to an AST element wrapped in a Just+ajs a@(Just (L l _)) bs = addAnnsAt l bs >> return a++-- |Add a list of AddAnns to the given AST element, where the AST element is the+-- result of a monadic action+amms :: P (Located a) -> [AddAnn] -> P (Located a)+amms a bs = do { av@(L l _) <- a+ ; addAnnsAt l bs+ ; return av }++-- |Add a list of AddAnns to the AST element, and return the element as a+-- OrdList+amsu :: Located a -> [AddAnn] -> P (OrdList (Located a))+amsu a@(L l _) bs = addAnnsAt l bs >> return (unitOL a)++-- |Synonyms for AddAnn versions of AnnOpen and AnnClose+mo,mc :: Located Token -> AddAnn+mo ll = mj AnnOpen ll+mc ll = mj AnnClose ll++moc,mcc :: Located Token -> AddAnn+moc ll = mj AnnOpenC ll+mcc ll = mj AnnCloseC ll++mop,mcp :: Located Token -> AddAnn+mop ll = mj AnnOpenP ll+mcp ll = mj AnnCloseP ll++mos,mcs :: Located Token -> AddAnn+mos ll = mj AnnOpenS ll+mcs ll = mj AnnCloseS ll++-- |Given a list of the locations of commas, provide a [AddAnn] with an AnnComma+-- entry for each SrcSpan+mcommas :: [SrcSpan] -> [AddAnn]+mcommas ss = map (\s -> mj AnnCommaTuple (L s ())) ss++-- |Given a list of the locations of '|'s, provide a [AddAnn] with an AnnVbar+-- entry for each SrcSpan+mvbars :: [SrcSpan] -> [AddAnn]+mvbars ss = map (\s -> mj AnnVbar (L s ())) ss++-- |Get the location of the last element of a OrdList, or noSrcSpan+oll :: OrdList (Located a) -> SrcSpan+oll l =+ if isNilOL l then noSrcSpan+ else getLoc (lastOL l)++-- |Add a semicolon annotation in the right place in a list. If the+-- leading list is empty, add it to the tail+asl :: [Located a] -> Located b -> Located a -> P()+asl [] (L ls _) (L l _) = addAnnotation l AnnSemi ls+asl (x:_xs) (L ls _) _x = addAnnotation (getLoc x) AnnSemi ls++sst ::HasSourceText a => SourceText -> a+sst = setSourceText {-# LINE 1 "templates/GenericTemplate.hs" #-} {-# LINE 1 "templates/GenericTemplate.hs" #-} {-# LINE 1 "<built-in>" #-}
ghc.cabal view
@@ -1,12 +1,13 @@ Cabal-Version: 2.0 Name: ghc-Version: 8.2.2+Version: 8.4.1 License: BSD3 License-File: LICENSE Author: The GHC Team Maintainer: glasgow-haskell-users@haskell.org Homepage: http://www.haskell.org/ghc/+Bug-Reports: https://ghc.haskell.org/trac/ghc/newticket?component=Compiler&keywords=lib:ghc Synopsis: The GHC API Description: GHC's functionality can be useful for more things than just@@ -24,6 +25,7 @@ HsVersions.h nativeGen/NCG.h parser/cutils.h+ autogen/ghc_boot_platform.h autogen/CodeGen.Platform.hs autogen/Config.hs@@ -45,10 +47,15 @@ Default: False Manual: True +source-repository head+ type: Git+ location: https://git.haskell.org/ghc.git+ subdir: compiler+ Library -- The generated code in autogen/ has been generated for a linux/x86_64 target -- So everything else is definitely not working...- if !(os(linux) && arch(x86_64) && impl(ghc == 8.2.2))+ if !(os(linux) && arch(x86_64) && impl(ghc == 8.4.1)) build-depends: base<0 -- ...while this package may in theory allow to reinstall lib:ghc@@ -63,7 +70,7 @@ Default-Language: Haskell2010 Exposed: False - Build-Depends: base == 4.10.*,+ Build-Depends: base == 4.11.*, deepseq >= 1.4 && < 1.5, directory >= 1 && < 1.4, process >= 1 && < 1.7,@@ -73,16 +80,15 @@ containers >= 0.5 && < 0.6, array >= 0.1 && < 0.6, filepath >= 1 && < 1.5,- template-haskell == 2.12.*,+ template-haskell == 2.13.*, hpc == 0.6.*, transformers == 0.5.*,- ghc-boot == 8.2.2,- ghc-boot-th == 8.2.2,- ghci == 8.2.2,- hoopl >= 3.10.2 && < 3.11+ ghc-boot == 8.4.1,+ ghc-boot-th == 8.4.1,+ ghci == 8.4.1 if os(windows)- Build-Depends: Win32 >= 2.3 && < 2.6+ Build-Depends: Win32 >= 2.3 && < 2.7 else if flag(terminfo) Build-Depends: terminfo == 0.4.*@@ -90,11 +96,15 @@ build-tools: alex ^>= 3.2.1, happy ^>= 1.19.5 - GHC-Options: -Wall -fno-warn-name-shadowing+ GHC-Options: -Wall+ -Wno-name-shadowing+ -Wnoncanonical-monad-instances+ -Wnoncanonical-monadfail-instances+ -Wnoncanonical-monoid-instances -- if flag(ghci)- -- CPP-Options: -DGHCI- -- Include-Dirs: ../rts/dist/build+ -- CPP-Options: -DGHCI+ -- Include-Dirs: ../rts/dist/build Other-Extensions: BangPatterns@@ -128,14 +138,8 @@ Include-Dirs: . parser utils -- We need to set the unit id to ghc (without a version number)- -- as it's magic. But we can't set it for old versions of GHC (e.g.- -- when bootstrapping) because those versions of GHC don't understand- -- that GHC is wired-in.- if impl ( ghc >= 7.11 )- GHC-Options: -this-unit-id ghc- else- if impl( ghc >= 7.9 )- GHC-Options: -this-package-key ghc+ -- as it's magic.+ GHC-Options: -this-unit-id ghc cpp-options: -DSTAGE=2 @@ -179,12 +183,22 @@ utils vectorise + -- we use an explicit Prelude+ Default-Extensions:+ NoImplicitPrelude++ Other-Modules:+ GhcPrelude+ Exposed-Modules:+ Ar+ FileCleanup DriverBkp BkpSyn NameShape RnModIface Avail+ AsmUtils BasicTypes ConLike DataCon@@ -251,6 +265,7 @@ CmmType CmmUtils CmmLayoutStack+ EnumSet MkGraph PprBase PprC@@ -326,6 +341,7 @@ HsImpExp HsLit PlaceHolder+ HsExtension HsPat HsSyn HsTypes@@ -372,7 +388,12 @@ PprTyThing StaticPtrTable SysTools+ SysTools.BaseDir SysTools.Terminal+ SysTools.ExtraObj+ SysTools.Info+ SysTools.Process+ SysTools.Tasks Elf TidyPgm Ctype@@ -392,7 +413,6 @@ TysWiredIn CostCentre ProfInit- SCCfinal RnBinds RnEnv RnExpr@@ -402,6 +422,9 @@ RnSource RnSplice RnTypes+ RnFixity+ RnUtils+ RnUnbound CoreMonad CSE FloatIn@@ -428,6 +451,7 @@ StgSyn CallArity DmdAnal+ Exitify WorkWrap WwLib FamInst@@ -523,6 +547,7 @@ UniqDFM UniqDSet UniqFM+ UniqMap UniqSet Util Vectorise.Builtins.Base@@ -554,8 +579,12 @@ Vectorise.Env Vectorise.Exp Vectorise+ Hoopl.Block+ Hoopl.Collections Hoopl.Dataflow- Hoopl+ Hoopl.Graph+ Hoopl.Label+ Hoopl.Unique -- CgInfoTbls used in ghci/DebuggerUtils -- CgHeapery mkVirtHeapOffsets used in ghci @@ -635,9 +664,3 @@ RtClosureInspect DebuggerUtils GHCi-- -- ghc:Serialized moved to ghc-boot:GHC.Serialized. So for- -- compatibility with GHC 7.10 and earlier, we reexport it- -- under the old name.- reexported-modules:- ghc-boot:GHC.Serialized as Serialized
ghci/ByteCodeAsm.hs view
@@ -15,6 +15,8 @@ #include "HsVersions.h" +import GhcPrelude+ import ByteCodeInstr import ByteCodeItbls import ByteCodeTypes@@ -194,7 +196,7 @@ return ul_bco -mkBitmapArray :: Word16 -> [StgWord] -> UArray Int Word+mkBitmapArray :: Word16 -> [StgWord] -> UArray Int Word64 -- Here the return type must be an array of Words, not StgWords, -- because the underlying ByteArray# will end up as a component -- of a BCO object.@@ -349,6 +351,12 @@ PUSH_L o1 -> emit bci_PUSH_L [SmallOp o1] PUSH_LL o1 o2 -> emit bci_PUSH_LL [SmallOp o1, SmallOp o2] PUSH_LLL o1 o2 o3 -> emit bci_PUSH_LLL [SmallOp o1, SmallOp o2, SmallOp o3]+ PUSH8 o1 -> emit bci_PUSH8 [SmallOp o1]+ PUSH16 o1 -> emit bci_PUSH16 [SmallOp o1]+ PUSH32 o1 -> emit bci_PUSH32 [SmallOp o1]+ PUSH8_W o1 -> emit bci_PUSH8_W [SmallOp o1]+ PUSH16_W o1 -> emit bci_PUSH16_W [SmallOp o1]+ PUSH32_W o1 -> emit bci_PUSH32_W [SmallOp o1] PUSH_G nm -> do p <- ptr (BCOPtrName nm) emit bci_PUSH_G [Op p] PUSH_PRIMOP op -> do p <- ptr (BCOPtrPrimOp op)@@ -363,6 +371,15 @@ -> do let ul_bco = assembleBCO dflags proto p <- ioptr (liftM BCOPtrBCO ul_bco) emit (push_alts pk) [Op p]+ PUSH_PAD8 -> emit bci_PUSH_PAD8 []+ PUSH_PAD16 -> emit bci_PUSH_PAD16 []+ PUSH_PAD32 -> emit bci_PUSH_PAD32 []+ PUSH_UBX8 lit -> do np <- literal lit+ emit bci_PUSH_UBX8 [Op np]+ PUSH_UBX16 lit -> do np <- literal lit+ emit bci_PUSH_UBX16 [Op np]+ PUSH_UBX32 lit -> do np <- literal lit+ emit bci_PUSH_UBX32 [Op np] PUSH_UBX lit nws -> do np <- literal lit emit bci_PUSH_UBX [Op np, SmallOp nws]
ghci/ByteCodeGen.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE CPP, MagicHash, RecordWildCards, BangPatterns #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# OPTIONS_GHC -fprof-auto-top #-} -- -- (c) The University of Glasgow 2002-2006@@ -9,6 +10,8 @@ #include "HsVersions.h" +import GhcPrelude+ import ByteCodeInstr import ByteCodeAsm import ByteCodeTypes@@ -43,8 +46,11 @@ import Unique import FastString import Panic-import StgCmmLayout ( ArgRep(..), toArgRep, argRepSizeW )-import SMRep+import StgCmmClosure ( NonVoid(..), fromNonVoid, nonVoidIds )+import StgCmmLayout ( ArgRep(..), FieldOffOrPadding(..),+ toArgRep, argRepSizeW,+ mkVirtHeapOffsetsWithPadding, mkVirtConstrOffsets )+import SMRep hiding (WordOff, ByteOff, wordsToBytes) import Bitmap import OrdList import Maybes@@ -68,11 +74,7 @@ import qualified Data.IntMap as IntMap import qualified FiniteMap as Map import Data.Ord-#if MIN_VERSION_base(4,9,0) import GHC.Stack.CCS-#else-import GHC.Stack as GHC.Stack.CCS-#endif -- ----------------------------------------------------------------------------- -- Generating byte code for a complete module@@ -139,7 +141,7 @@ Here is a summary on how the byte code generator deals with top-level string literals: -1. Top-level string literal bindings are spearted from the rest of the module.+1. Top-level string literal bindings are separated from the rest of the module. 2. The strings are allocated via iservCmd, in allocateTopStrings @@ -209,12 +211,34 @@ type BCInstrList = OrdList BCInstr -type Sequel = Word -- back off to this depth before ENTER+newtype ByteOff = ByteOff Int+ deriving (Enum, Eq, Integral, Num, Ord, Real) --- Maps Ids to the offset from the stack _base_ so we don't have--- to mess with it after each push/pop.-type BCEnv = Map Id Word -- To find vars on the stack+newtype WordOff = WordOff Int+ deriving (Enum, Eq, Integral, Num, Ord, Real) +wordsToBytes :: DynFlags -> WordOff -> ByteOff+wordsToBytes dflags = fromIntegral . (* wORD_SIZE dflags) . fromIntegral++-- Used when we know we have a whole number of words+bytesToWords :: DynFlags -> ByteOff -> WordOff+bytesToWords dflags (ByteOff bytes) =+ let (q, r) = bytes `quotRem` (wORD_SIZE dflags)+ in if r == 0+ then fromIntegral q+ else panic $ "ByteCodeGen.bytesToWords: bytes=" ++ show bytes++wordSize :: DynFlags -> ByteOff+wordSize dflags = ByteOff (wORD_SIZE dflags)++type Sequel = ByteOff -- back off to this depth before ENTER++type StackDepth = ByteOff++-- | Maps Ids to their stack depth. This allows us to avoid having to mess with+-- it after each push/pop.+type BCEnv = Map Id StackDepth -- To find vars on the stack+ {- ppBCEnv :: BCEnv -> SDoc ppBCEnv p@@ -296,8 +320,6 @@ -- Compile code for the right-hand side of a top-level binding schemeTopBind :: (Id, AnnExpr Id DVarSet) -> BcM (ProtoBCO Name)-- schemeTopBind (id, rhs) | Just data_con <- isDataConWorkId_maybe id, isNullaryRepDataCon data_con = do@@ -358,7 +380,12 @@ = go (x:xs) e go xs not_lambda = (reverse xs, not_lambda) -schemeR_wrk :: [Id] -> Id -> AnnExpr Id DVarSet -> ([Var], AnnExpr' Var DVarSet) -> BcM (ProtoBCO Name)+schemeR_wrk+ :: [Id]+ -> Id+ -> AnnExpr Id DVarSet+ -> ([Var], AnnExpr' Var DVarSet)+ -> BcM (ProtoBCO Name) schemeR_wrk fvs nm original_body (args, body) = do dflags <- getDynFlags@@ -369,27 +396,30 @@ -- \fv1..fvn x1..xn -> e -- i.e. the fvs come first - szsw_args = map (fromIntegral . idSizeW dflags) all_args- szw_args = sum szsw_args- p_init = Map.fromList (zip all_args (mkStackOffsets 0 szsw_args))+ -- Stack arguments always take a whole number of words, we never pack+ -- them unlike constructor fields.+ szsb_args = map (wordsToBytes dflags . idSizeW dflags) all_args+ sum_szsb_args = sum szsb_args+ p_init = Map.fromList (zip all_args (mkStackOffsets 0 szsb_args)) -- make the arg bitmap bits = argBits dflags (reverse (map bcIdArgRep all_args)) bitmap_size = genericLength bits bitmap = mkBitmap dflags bits- body_code <- schemeER_wrk szw_args p_init body+ body_code <- schemeER_wrk sum_szsb_args p_init body emitBc (mkProtoBCO dflags (getName nm) body_code (Right original_body) arity bitmap_size bitmap False{-not alts-}) -- introduce break instructions for ticked expressions-schemeER_wrk :: Word -> BCEnv -> AnnExpr' Id DVarSet -> BcM BCInstrList+schemeER_wrk :: StackDepth -> BCEnv -> AnnExpr' Id DVarSet -> BcM BCInstrList schemeER_wrk d p rhs | AnnTick (Breakpoint tick_no fvs) (_annot, newRhs) <- rhs- = do code <- schemeE (fromIntegral d) 0 p newRhs+ = do code <- schemeE d 0 p newRhs cc_arr <- getCCArray this_mod <- moduleName <$> getCurrentModule- let idOffSets = getVarOffSets d p fvs+ dflags <- getDynFlags+ let idOffSets = getVarOffSets dflags d p fvs let breakInfo = CgBreakInfo { cgb_vars = idOffSets , cgb_resty = exprType (deAnnotate' newRhs)@@ -400,24 +430,38 @@ | otherwise = toRemotePtr nullPtr let breakInstr = BRK_FUN (fromIntegral tick_no) (getUnique this_mod) cc return $ breakInstr `consOL` code- | otherwise = schemeE (fromIntegral d) 0 p rhs--getVarOffSets :: Word -> BCEnv -> [Id] -> [(Id, Word16)]-getVarOffSets d p = catMaybes . map (getOffSet d p)+ | otherwise = schemeE d 0 p rhs -getOffSet :: Word -> BCEnv -> Id -> Maybe (Id, Word16)-getOffSet d env id- = case lookupBCEnv_maybe id env of+getVarOffSets :: DynFlags -> StackDepth -> BCEnv -> [Id] -> [(Id, Word16)]+getVarOffSets dflags depth env = catMaybes . map getOffSet+ where+ getOffSet id = case lookupBCEnv_maybe id env of Nothing -> Nothing- Just offset -> Just (id, trunc16 $ d - offset)+ Just offset ->+ -- michalt: I'm not entirely sure why we need the stack+ -- adjustment by 2 here. I initially thought that there's+ -- something off with getIdValFromApStack (the only user of this+ -- value), but it looks ok to me. My current hypothesis is that+ -- this "adjustment" is needed due to stack manipulation for+ -- BRK_FUN in Interpreter.c In any case, this is used only when+ -- we trigger a breakpoint.+ let !var_depth_ws =+ trunc16W $ bytesToWords dflags (depth - offset) + 2+ in Just (id, var_depth_ws) -trunc16 :: Word -> Word16-trunc16 w+truncIntegral16 :: Integral a => a -> Word16+truncIntegral16 w | w > fromIntegral (maxBound :: Word16) = panic "stack depth overflow" | otherwise = fromIntegral w +trunc16B :: ByteOff -> Word16+trunc16B = truncIntegral16++trunc16W :: WordOff -> Word16+trunc16W = truncIntegral16+ fvsToEnv :: BCEnv -> DVarSet -> [Id] -- Takes the free variables of a right-hand side, and -- delivers an ordered list of the local variables that will@@ -434,21 +478,26 @@ -- ----------------------------------------------------------------------------- -- schemeE -returnUnboxedAtom :: Word -> Sequel -> BCEnv- -> AnnExpr' Id DVarSet -> ArgRep- -> BcM BCInstrList+returnUnboxedAtom+ :: StackDepth+ -> Sequel+ -> BCEnv+ -> AnnExpr' Id DVarSet+ -> ArgRep+ -> BcM BCInstrList -- Returning an unlifted value. -- Heave it on the stack, SLIDE, and RETURN.-returnUnboxedAtom d s p e e_rep- = do (push, szw) <- pushAtom d p e- return (push -- value onto stack- `appOL` mkSLIDE szw (d-s) -- clear to sequel- `snocOL` RETURN_UBX e_rep) -- go+returnUnboxedAtom d s p e e_rep = do+ dflags <- getDynFlags+ (push, szb) <- pushAtom d p e+ return (push -- value onto stack+ `appOL` mkSlideB dflags szb (d - s) -- clear to sequel+ `snocOL` RETURN_UBX e_rep) -- go -- Compile code to apply the given expression to the remaining args -- on the stack, returning a HNF.-schemeE :: Word -> Sequel -> BCEnv -> AnnExpr' Id DVarSet -> BcM BCInstrList-+schemeE+ :: StackDepth -> Sequel -> BCEnv -> AnnExpr' Id DVarSet -> BcM BCInstrList schemeE d s p e | Just e' <- bcView e = schemeE d s p e'@@ -471,7 +520,9 @@ -- saturated constructor application. -- Just allocate the constructor and carry on alloc_code <- mkConAppCode d s p data_con args_r_to_l- body_code <- schemeE (d+1) s (Map.insert x d p) body+ dflags <- getDynFlags+ let !d2 = d + wordSize dflags+ body_code <- schemeE d2 s (Map.insert x d2 p) body return (alloc_code `appOL` body_code) -- General case for let. Generates correct, if inefficient, code in@@ -485,28 +536,39 @@ fvss = map (fvsToEnv p' . fst) rhss -- Sizes of free vars- sizes = map (\rhs_fvs -> sum (map (fromIntegral . idSizeW dflags) rhs_fvs)) fvss+ size_w = trunc16W . idSizeW dflags+ sizes = map (\rhs_fvs -> sum (map size_w rhs_fvs)) fvss -- the arity of each rhs arities = map (genericLength . fst . collect) rhss -- This p', d' defn is safe because all the items being pushed- -- are ptrs, so all have size 1. d' and p' reflect the stack+ -- are ptrs, so all have size 1 word. d' and p' reflect the stack -- after the closures have been allocated in the heap (but not -- filled in), and pointers to them parked on the stack.- p' = Map.insertList (zipE xs (mkStackOffsets d (genericReplicate n_binds 1))) p- d' = d + fromIntegral n_binds- zipE = zipEqual "schemeE"+ offsets = mkStackOffsets d (genericReplicate n_binds (wordSize dflags))+ p' = Map.insertList (zipE xs offsets) p+ d' = d + wordsToBytes dflags n_binds+ zipE = zipEqual "schemeE" -- ToDo: don't build thunks for things with no free variables+ build_thunk+ :: StackDepth+ -> [Id]+ -> Word16+ -> ProtoBCO Name+ -> Word16+ -> Word16+ -> BcM BCInstrList build_thunk _ [] size bco off arity = return (PUSH_BCO bco `consOL` unitOL (mkap (off+size) size)) where mkap | arity == 0 = MKAP | otherwise = MKPAP build_thunk dd (fv:fvs) size bco off arity = do- (push_code, pushed_szw) <- pushAtom dd p' (AnnVar fv)- more_push_code <- build_thunk (dd + fromIntegral pushed_szw) fvs size bco off arity+ (push_code, pushed_szb) <- pushAtom dd p' (AnnVar fv)+ more_push_code <-+ build_thunk (dd + pushed_szb) fvs size bco off arity return (push_code `appOL` more_push_code) alloc_code = toOL (zipWith mkAlloc sizes arities)@@ -524,7 +586,7 @@ build_thunk d' fvs size bco off arity compile_binds =- [ compile_bind d' fvs x rhs size arity n+ [ compile_bind d' fvs x rhs size arity (trunc16W n) | (fvs, x, rhs, size, arity, n) <- zip6 fvss xs rhss sizes arities [n_binds, n_binds-1 .. 1] ]@@ -600,7 +662,7 @@ schemeE d s p (AnnCase scrut bndr _ [(DataAlt dc, [bind1], rhs)]) | isUnboxedTupleCon dc- , length (typePrimRep (idType bndr)) <= 1 -- handles unit tuples+ , typePrimRep (idType bndr) `lengthAtMost` 1 -- handles unit tuples = doCase d s p scrut bind1 [(DEFAULT, [], rhs)] (Just bndr) schemeE d s p (AnnCase scrut bndr _ alt@[(DEFAULT, [], _)])@@ -653,7 +715,7 @@ -- 4. Otherwise, it must be a function call. Push the args -- right to left, SLIDE and ENTER. -schemeT :: Word -- Stack depth+schemeT :: StackDepth -- Stack depth -> Sequel -- Sequel depth -> BCEnv -- stack env -> AnnExpr' Id DVarSet@@ -661,12 +723,6 @@ schemeT d s p app --- | trace ("schemeT: env in = \n" ++ showSDocDebug (ppBCEnv p)) False--- = panic "schemeT ?!?!"---- | trace ("\nschemeT\n" ++ showSDoc (pprCoreExpr (deAnnotate' app)) ++ "\n") False--- = error "?!?!"- -- Case 0 | Just (arg, constr_names) <- maybe_is_tagToEnum_call app = implement_tagToId d s p arg constr_names@@ -691,8 +747,9 @@ -- Case 3: Ordinary data constructor | Just con <- maybe_saturated_dcon = do alloc_con <- mkConAppCode d s p con args_r_to_l+ dflags <- getDynFlags return (alloc_con `appOL`- mkSLIDE 1 (d - s) `snocOL`+ mkSlideW 1 (bytesToWords dflags $ d - s) `snocOL` ENTER) -- Case 4: Tail call of function@@ -717,35 +774,51 @@ -- Generate code to build a constructor application, -- leaving it on top of the stack -mkConAppCode :: Word -> Sequel -> BCEnv- -> DataCon -- The data constructor- -> [AnnExpr' Id DVarSet] -- Args, in *reverse* order- -> BcM BCInstrList-+mkConAppCode+ :: StackDepth+ -> Sequel+ -> BCEnv+ -> DataCon -- The data constructor+ -> [AnnExpr' Id DVarSet] -- Args, in *reverse* order+ -> BcM BCInstrList mkConAppCode _ _ _ con [] -- Nullary constructor = ASSERT( isNullaryRepDataCon con ) return (unitOL (PUSH_G (getName (dataConWorkId con)))) -- Instead of doing a PACK, which would allocate a fresh -- copy of this constructor, use the single shared version. -mkConAppCode orig_d _ p con args_r_to_l- = ASSERT( dataConRepArity con == length args_r_to_l )- do_pushery orig_d (non_ptr_args ++ ptr_args)- where- -- The args are already in reverse order, which is the way PACK- -- expects them to be. We must push the non-ptrs after the ptrs.- (ptr_args, non_ptr_args) = partition isPtrAtom args_r_to_l+mkConAppCode orig_d _ p con args_r_to_l =+ ASSERT( args_r_to_l `lengthIs` dataConRepArity con ) app_code+ where+ app_code = do+ dflags <- getDynFlags - do_pushery d (arg:args)- = do (push, arg_words) <- pushAtom d p arg- more_push_code <- do_pushery (d + fromIntegral arg_words) args- return (push `appOL` more_push_code)- do_pushery d []- = return (unitOL (PACK con n_arg_words))- where- n_arg_words = trunc16 $ d - orig_d+ -- The args are initially in reverse order, but mkVirtHeapOffsets+ -- expects them to be left-to-right.+ let non_voids =+ [ NonVoid (prim_rep, arg)+ | arg <- reverse args_r_to_l+ , let prim_rep = atomPrimRep arg+ , not (isVoidRep prim_rep)+ ]+ is_thunk = False+ (_, _, args_offsets) =+ mkVirtHeapOffsetsWithPadding dflags is_thunk non_voids + do_pushery !d (arg : args) = do+ (push, arg_bytes) <- case arg of+ (Padding l _) -> pushPadding l+ (FieldOff a _) -> pushConstrAtom d p (fromNonVoid a)+ more_push_code <- do_pushery (d + arg_bytes) args+ return (push `appOL` more_push_code)+ do_pushery !d [] = do+ let !n_arg_words = trunc16W $ bytesToWords dflags (d - orig_d)+ return (unitOL (PACK con n_arg_words)) + -- Push on the stack in the reverse order.+ do_pushery orig_d (reverse args_offsets)++ -- ----------------------------------------------------------------------------- -- Returning an unboxed tuple with one non-void component (the only -- case we can handle).@@ -754,39 +827,41 @@ -- returned, even if it is a pointed type. We always just return. unboxedTupleReturn- :: Word -> Sequel -> BCEnv- -> AnnExpr' Id DVarSet -> BcM BCInstrList+ :: StackDepth -> Sequel -> BCEnv -> AnnExpr' Id DVarSet -> BcM BCInstrList unboxedTupleReturn d s p arg = returnUnboxedAtom d s p arg (atomRep arg) -- ----------------------------------------------------------------------------- -- Generate code for a tail-call doTailCall- :: Word -> Sequel -> BCEnv- -> Id -> [AnnExpr' Id DVarSet]- -> BcM BCInstrList-doTailCall init_d s p fn args- = do_pushes init_d args (map atomRep args)+ :: StackDepth+ -> Sequel+ -> BCEnv+ -> Id+ -> [AnnExpr' Id DVarSet]+ -> BcM BCInstrList+doTailCall init_d s p fn args = do_pushes init_d args (map atomRep args) where- do_pushes d [] reps = do+ do_pushes !d [] reps = do ASSERT( null reps ) return () (push_fn, sz) <- pushAtom d p (AnnVar fn)- ASSERT( sz == 1 ) return ()- return (push_fn `appOL` (- mkSLIDE (trunc16 $ d - init_d + 1) (init_d - s) `appOL`- unitOL ENTER))- do_pushes d args reps = do+ dflags <- getDynFlags+ ASSERT( sz == wordSize dflags ) return ()+ let slide = mkSlideB dflags (d - init_d + wordSize dflags) (init_d - s)+ return (push_fn `appOL` (slide `appOL` unitOL ENTER))+ do_pushes !d args reps = do let (push_apply, n, rest_of_reps) = findPushSeq reps (these_args, rest_of_args) = splitAt n args (next_d, push_code) <- push_seq d these_args- instrs <- do_pushes (next_d + 1) rest_of_args rest_of_reps+ dflags <- getDynFlags+ instrs <- do_pushes (next_d + wordSize dflags) rest_of_args rest_of_reps -- ^^^ for the PUSH_APPLY_ instruction return (push_code `appOL` (push_apply `consOL` instrs)) push_seq d [] = return (d, nilOL) push_seq d (arg:args) = do (push_code, sz) <- pushAtom d p arg- (final_d, more_push_code) <- push_seq (d + fromIntegral sz) args+ (final_d, more_push_code) <- push_seq (d + sz) args return (final_d, push_code `appOL` more_push_code) -- v. similar to CgStackery.findMatch, ToDo: merge@@ -819,10 +894,16 @@ -- ----------------------------------------------------------------------------- -- Case expressions -doCase :: Word -> Sequel -> BCEnv- -> AnnExpr Id DVarSet -> Id -> [AnnAlt Id DVarSet]- -> Maybe Id -- Just x <=> is an unboxed tuple case with scrut binder, don't enter the result- -> BcM BCInstrList+doCase+ :: StackDepth+ -> Sequel+ -> BCEnv+ -> AnnExpr Id DVarSet+ -> Id+ -> [AnnAlt Id DVarSet]+ -> Maybe Id -- Just x <=> is an unboxed tuple case with scrut binder,+ -- don't enter the result+ -> BcM BCInstrList doCase d s p (_,scrut) bndr alts is_unboxed_tuple | typePrimRep (idType bndr) `lengthExceeds` 1 = multiValException@@ -838,33 +919,34 @@ -- underneath it is the pointer to the alt_code BCO. -- When an alt is entered, it assumes the returned value is -- on top of the itbl.- ret_frame_sizeW :: Word- ret_frame_sizeW = 2+ ret_frame_size_b :: StackDepth+ ret_frame_size_b = 2 * wordSize dflags -- The extra frame we push to save/restor the CCCS when profiling- save_ccs_sizeW | profiling = 2- | otherwise = 0+ save_ccs_size_b | profiling = 2 * wordSize dflags+ | otherwise = 0 -- An unlifted value gets an extra info table pushed on top -- when it is returned.- unlifted_itbl_sizeW :: Word- unlifted_itbl_sizeW | isAlgCase = 0- | otherwise = 1+ unlifted_itbl_size_b :: StackDepth+ unlifted_itbl_size_b | isAlgCase = 0+ | otherwise = wordSize dflags -- depth of stack after the return value has been pushed- d_bndr = d + ret_frame_sizeW + fromIntegral (idSizeW dflags bndr)+ d_bndr =+ d + ret_frame_size_b + wordsToBytes dflags (idSizeW dflags bndr) -- depth of stack after the extra info table for an unboxed return -- has been pushed, if any. This is the stack depth at the -- continuation.- d_alts = d_bndr + unlifted_itbl_sizeW+ d_alts = d_bndr + unlifted_itbl_size_b -- Env in which to compile the alts, not including -- any vars bound by the alts themselves- d_bndr' = fromIntegral d_bndr - 1- p_alts0 = Map.insert bndr d_bndr' p+ p_alts0 = Map.insert bndr d_bndr p+ p_alts = case is_unboxed_tuple of- Just ubx_bndr -> Map.insert ubx_bndr d_bndr' p_alts0+ Just ubx_bndr -> Map.insert ubx_bndr d_bndr p_alts0 Nothing -> p_alts0 bndr_ty = idType bndr@@ -880,23 +962,32 @@ | null real_bndrs = do rhs_code <- schemeE d_alts s p_alts rhs return (my_discr alt, rhs_code)+ -- If an alt attempts to match on an unboxed tuple or sum, we must+ -- bail out, as the bytecode compiler can't handle them.+ -- (See Trac #14608.)+ | any (\bndr -> typePrimRep (idType bndr) `lengthExceeds` 1) bndrs+ = multiValException -- algebraic alt with some binders | otherwise =- let- (ptrs,nptrs) = partition (isFollowableArg.bcIdArgRep) real_bndrs- ptr_sizes = map (fromIntegral . idSizeW dflags) ptrs- nptrs_sizes = map (fromIntegral . idSizeW dflags) nptrs- bind_sizes = ptr_sizes ++ nptrs_sizes- size = sum ptr_sizes + sum nptrs_sizes- -- the UNPACK instruction unpacks in reverse order...+ let (tot_wds, _ptrs_wds, args_offsets) =+ mkVirtConstrOffsets dflags+ [ NonVoid (bcIdPrimRep id, id)+ | NonVoid id <- nonVoidIds real_bndrs+ ]+ size = WordOff tot_wds++ stack_bot = d_alts + wordsToBytes dflags size++ -- convert offsets from Sp into offsets into the virtual stack p' = Map.insertList- (zip (reverse (ptrs ++ nptrs))- (mkStackOffsets d_alts (reverse bind_sizes)))+ [ (arg, stack_bot + wordSize dflags - ByteOff offset)+ | (NonVoid arg, offset) <- args_offsets ] p_alts in do MASSERT(isAlgCase)- rhs_code <- schemeE (d_alts + size) s p' rhs- return (my_discr alt, unitOL (UNPACK (trunc16 size)) `appOL` rhs_code)+ rhs_code <- schemeE stack_bot s p' rhs+ return (my_discr alt,+ unitOL (UNPACK (trunc16W size)) `appOL` rhs_code) where real_bndrs = filterOut isTyVar bndrs @@ -935,7 +1026,7 @@ -- really want a bitmap up to depth (d-s). This affects compilation of -- case-of-case expressions, which is the only time we can be compiling a -- case expression with s /= 0.- bitmap_size = trunc16 $ d-s+ bitmap_size = trunc16W $ bytesToWords dflags (d - s) bitmap_size' :: Int bitmap_size' = fromIntegral bitmap_size bitmap = intsToReverseBitmap dflags bitmap_size'{-size-}@@ -947,7 +1038,7 @@ rel_slots = nub $ map fromIntegral $ concat (map spread binds) spread (id, offset) | isFollowableArg (bcIdArgRep id) = [ rel_offset ] | otherwise = []- where rel_offset = trunc16 $ d - fromIntegral offset - 1+ where rel_offset = trunc16W $ bytesToWords dflags (d - offset) alt_stuff <- mapM codeAlt alts alt_final <- mkMultiBranch maybe_ncons alt_stuff@@ -959,8 +1050,8 @@ -- trace ("case: bndr = " ++ showSDocDebug (ppr bndr) ++ "\ndepth = " ++ show d ++ "\nenv = \n" ++ showSDocDebug (ppBCEnv p) ++ -- "\n bitmap = " ++ show bitmap) $ do - scrut_code <- schemeE (d + ret_frame_sizeW + save_ccs_sizeW)- (d + ret_frame_sizeW + save_ccs_sizeW)+ scrut_code <- schemeE (d + ret_frame_size_b + save_ccs_size_b)+ (d + ret_frame_size_b + save_ccs_size_b) p scrut alt_bco' <- emitBc alt_bco let push_alts@@ -978,27 +1069,30 @@ -- (machine) code for the ccall, and create bytecodes to call that and -- then return in the right way. -generateCCall :: Word -> Sequel -- stack and sequel depths- -> BCEnv- -> CCallSpec -- where to call- -> Id -- of target, for type info- -> [AnnExpr' Id DVarSet] -- args (atoms)- -> BcM BCInstrList-+generateCCall+ :: StackDepth+ -> Sequel+ -> BCEnv+ -> CCallSpec -- where to call+ -> Id -- of target, for type info+ -> [AnnExpr' Id DVarSet] -- args (atoms)+ -> BcM BCInstrList generateCCall d0 s p (CCallSpec target cconv safety) fn args_r_to_l = do dflags <- getDynFlags let -- useful constants- addr_sizeW :: Word16- addr_sizeW = fromIntegral (argRepSizeW dflags N)+ addr_size_b :: ByteOff+ addr_size_b = wordSize dflags -- Get the args on the stack, with tags and suitably -- dereferenced for the CCall. For each arg, return the -- depth to the first word of the bits for that arg, and the -- ArgRep of what was actually pushed. + pargs+ :: ByteOff -> [AnnExpr' Id DVarSet] -> BcM [(BCInstrList, PrimRep)] pargs _ [] = return [] pargs d (a:az) = let arg_ty = unwrapType (exprType (deAnnotate' a))@@ -1008,31 +1102,35 @@ -- contains. Just t | t == arrayPrimTyCon || t == mutableArrayPrimTyCon- -> do rest <- pargs (d + fromIntegral addr_sizeW) az+ -> do rest <- pargs (d + addr_size_b) az code <- parg_ArrayishRep (fromIntegral (arrPtrsHdrSize dflags)) d p a return ((code,AddrRep):rest) | t == smallArrayPrimTyCon || t == smallMutableArrayPrimTyCon- -> do rest <- pargs (d + fromIntegral addr_sizeW) az+ -> do rest <- pargs (d + addr_size_b) az code <- parg_ArrayishRep (fromIntegral (smallArrPtrsHdrSize dflags)) d p a return ((code,AddrRep):rest) | t == byteArrayPrimTyCon || t == mutableByteArrayPrimTyCon- -> do rest <- pargs (d + fromIntegral addr_sizeW) az+ -> do rest <- pargs (d + addr_size_b) az code <- parg_ArrayishRep (fromIntegral (arrWordsHdrSize dflags)) d p a return ((code,AddrRep):rest) -- Default case: push taggedly, but otherwise intact. _ -> do (code_a, sz_a) <- pushAtom d p a- rest <- pargs (d + fromIntegral sz_a) az+ rest <- pargs (d + sz_a) az return ((code_a, atomPrimRep a) : rest) -- Do magic for Ptr/Byte arrays. Push a ptr to the array on -- the stack but then advance it over the headers, so as to -- point to the payload.- parg_ArrayishRep :: Word16 -> Word -> BCEnv -> AnnExpr' Id DVarSet- -> BcM BCInstrList+ parg_ArrayishRep+ :: Word16+ -> StackDepth+ -> BCEnv+ -> AnnExpr' Id DVarSet+ -> BcM BCInstrList parg_ArrayishRep hdrSize d p a = do (push_fo, _) <- pushAtom d p a -- The ptr points at the header. Advance it over the@@ -1042,10 +1140,10 @@ code_n_reps <- pargs d0 args_r_to_l let (pushs_arg, a_reps_pushed_r_to_l) = unzip code_n_reps- a_reps_sizeW = fromIntegral (sum (map (primRepSizeW dflags) a_reps_pushed_r_to_l))+ a_reps_sizeW = sum (map (repSizeWords dflags) a_reps_pushed_r_to_l) push_args = concatOL pushs_arg- d_after_args = d0 + a_reps_sizeW+ !d_after_args = d0 + wordsToBytes dflags a_reps_sizeW a_reps_pushed_RAW | null a_reps_pushed_r_to_l || head a_reps_pushed_r_to_l /= VoidRep = panic "ByteCodeGen.generateCCall: missing or invalid World token?"@@ -1097,6 +1195,7 @@ void marshall_code ( StgWord* ptr_to_top_of_stack ) -} -- resolve static address+ maybe_static_target :: Maybe Literal maybe_static_target = case target of DynamicTarget -> Nothing@@ -1125,18 +1224,18 @@ -- push the Addr# (push_Addr, d_after_Addr) | Just machlabel <- maybe_static_target- = (toOL [PUSH_UBX machlabel addr_sizeW],- d_after_args + fromIntegral addr_sizeW)+ = (toOL [PUSH_UBX machlabel 1], d_after_args + addr_size_b) | otherwise -- is already on the stack = (nilOL, d_after_args) -- Push the return placeholder. For a call returning nothing, -- this is a V (tag).- r_sizeW = fromIntegral (primRepSizeW dflags r_rep)- d_after_r = d_after_Addr + fromIntegral r_sizeW- push_r = (if returns_void- then nilOL- else unitOL (PUSH_UBX (mkDummyLiteral r_rep) r_sizeW))+ r_sizeW = repSizeWords dflags r_rep+ d_after_r = d_after_Addr + wordsToBytes dflags r_sizeW+ push_r =+ if returns_void+ then nilOL+ else unitOL (PUSH_UBX (mkDummyLiteral r_rep) (trunc16W r_sizeW)) -- generate the marshalling code we're going to call @@ -1144,7 +1243,7 @@ -- instruction needs to describe the chunk of stack containing -- the ccall args to the GC, so it needs to know how large it -- is. See comment in Interpreter.c with the CCALL instruction.- stk_offset = trunc16 $ d_after_r - s+ stk_offset = trunc16W $ bytesToWords dflags (d_after_r - s) conv = case cconv of CCallConv -> FFICCall@@ -1164,10 +1263,15 @@ let -- do the call- do_call = unitOL (CCALL stk_offset token- (fromIntegral (fromEnum (playInterruptible safety))))+ do_call = unitOL (CCALL stk_offset token flags)+ where flags = case safety of+ PlaySafe -> 0x0+ PlayInterruptible -> 0x1+ PlayRisky -> 0x2+ -- slide and return- wrapup = mkSLIDE r_sizeW (d_after_r - fromIntegral r_sizeW - s)+ d_after_r_min_s = bytesToWords dflags (d_after_r - s)+ wrapup = mkSlideW (trunc16W r_sizeW) (d_after_r_min_s - r_sizeW) `snocOL` RETURN_UBX (toArgRep r_rep) --trace (show (arg1_offW, args_offW , (map argRepSizeW a_reps) )) $ return (@@ -1300,18 +1404,25 @@ -} -implement_tagToId :: Word -> Sequel -> BCEnv- -> AnnExpr' Id DVarSet -> [Name] -> BcM BCInstrList+implement_tagToId+ :: StackDepth+ -> Sequel+ -> BCEnv+ -> AnnExpr' Id DVarSet+ -> [Name]+ -> BcM BCInstrList -- See Note [Implementing tagToEnum#] implement_tagToId d s p arg names = ASSERT( notNull names )- do (push_arg, arg_words) <- pushAtom d p arg+ do (push_arg, arg_bytes) <- pushAtom d p arg labels <- getLabelsBc (genericLength names) label_fail <- getLabelBc label_exit <- getLabelBc+ dflags <- getDynFlags let infos = zip4 labels (tail labels ++ [label_fail]) [0 ..] names steps = map (mkStep label_exit) infos+ slide_ws = bytesToWords dflags (d - s + arg_bytes) return (push_arg `appOL` unitOL (PUSH_UBX MachNullAddr 1)@@ -1319,10 +1430,10 @@ `appOL` concatOL steps `appOL` toOL [ LABEL label_fail, CASEFAIL, LABEL label_exit ]- `appOL` mkSLIDE 1 (d - s + fromIntegral arg_words + 1)+ `appOL` mkSlideW 1 (slide_ws + 1) -- "+1" to account for bogus word -- (see Note [Implementing tagToEnum#])- `appOL` unitOL ENTER)+ `appOL` unitOL ENTER) where mkStep l_exit (my_label, next_label, n, name_for_n) = toOL [LABEL my_label,@@ -1344,8 +1455,8 @@ -- to 5 and not to 4. Stack locations are numbered from zero, so a -- depth 6 stack has valid words 0 .. 5. -pushAtom :: Word -> BCEnv -> AnnExpr' Id DVarSet -> BcM (BCInstrList, Word16)-+pushAtom+ :: StackDepth -> BCEnv -> AnnExpr' Id DVarSet -> BcM (BCInstrList, ByteOff) pushAtom d p e | Just e' <- bcView e = pushAtom d p e'@@ -1359,52 +1470,59 @@ pushAtom d p (AnnCase (_, a) _ _ []) -- trac #12128 = pushAtom d p a -pushAtom d p (AnnVar v)- | [] <- typePrimRep (idType v)+pushAtom d p (AnnVar var)+ | [] <- typePrimRep (idType var) = return (nilOL, 0) - | isFCallId v- = pprPanic "pushAtom: shouldn't get an FCallId here" (ppr v)+ | isFCallId var+ = pprPanic "pushAtom: shouldn't get an FCallId here" (ppr var) - | Just primop <- isPrimOpId_maybe v- = return (unitOL (PUSH_PRIMOP primop), 1)+ | Just primop <- isPrimOpId_maybe var+ = do+ dflags <-getDynFlags+ return (unitOL (PUSH_PRIMOP primop), wordSize dflags) - | Just d_v <- lookupBCEnv_maybe v p -- v is a local variable+ | Just d_v <- lookupBCEnv_maybe var p -- var is a local variable = do dflags <- getDynFlags- let sz :: Word16- sz = fromIntegral (idSizeW dflags v)- l = trunc16 $ d - d_v + fromIntegral sz - 2- return (toOL (genericReplicate sz (PUSH_L l)), sz)- -- d - d_v the number of words between the TOS- -- and the 1st slot of the object- --- -- d - d_v - 1 the offset from the TOS of the 1st slot- --- -- d - d_v - 1 + sz - 1 the offset from the TOS of the last slot- -- of the object.- --- -- Having found the last slot, we proceed to copy the right number of- -- slots on to the top of the stack. - | otherwise -- v must be a global variable+ let !szb = idSizeCon dflags var+ with_instr instr = do+ let !off_b = trunc16B $ d - d_v+ return (unitOL (instr off_b), wordSize dflags)++ case szb of+ 1 -> with_instr PUSH8_W+ 2 -> with_instr PUSH16_W+ 4 -> with_instr PUSH32_W+ _ -> do+ let !szw = bytesToWords dflags szb+ !off_w = trunc16W $ bytesToWords dflags (d - d_v) + szw - 1+ return (toOL (genericReplicate szw (PUSH_L off_w)), szb)+ -- d - d_v offset from TOS to the first slot of the object+ --+ -- d - d_v + sz - 1 offset from the TOS of the last slot of the object+ --+ -- Having found the last slot, we proceed to copy the right number of+ -- slots on to the top of the stack.++ | otherwise -- var must be a global variable = do topStrings <- getTopStrings- case lookupVarEnv topStrings v of+ case lookupVarEnv topStrings var of Just ptr -> pushAtom d p $ AnnLit $ MachWord $ fromIntegral $ ptrToWordPtr $ fromRemotePtr ptr Nothing -> do dflags <- getDynFlags- let sz :: Word16- sz = fromIntegral (idSizeW dflags v)- MASSERT(sz == 1)- return (unitOL (PUSH_G (getName v)), sz)+ let sz = idSizeCon dflags var+ MASSERT( sz == wordSize dflags )+ return (unitOL (PUSH_G (getName var)), sz) pushAtom _ _ (AnnLit lit) = do dflags <- getDynFlags let code rep- = let size_host_words = fromIntegral (argRepSizeW dflags rep)- in return (unitOL (PUSH_UBX lit size_host_words),- size_host_words)+ = let size_words = WordOff (argRepSizeW dflags rep)+ in return (unitOL (PUSH_UBX lit (trunc16W size_words)),+ wordsToBytes dflags size_words) case lit of MachLabel _ _ _ -> code N@@ -1427,6 +1545,36 @@ (pprCoreExpr (deAnnotate' expr)) +-- | Push an atom for constructor (i.e., PACK instruction) onto the stack.+-- This is slightly different to @pushAtom@ due to the fact that we allow+-- packing constructor fields. See also @mkConAppCode@ and @pushPadding@.+pushConstrAtom+ :: StackDepth -> BCEnv -> AnnExpr' Id DVarSet -> BcM (BCInstrList, ByteOff)++pushConstrAtom _ _ (AnnLit lit@(MachFloat _)) =+ return (unitOL (PUSH_UBX32 lit), 4)++pushConstrAtom d p (AnnVar v)+ | Just d_v <- lookupBCEnv_maybe v p = do -- v is a local variable+ dflags <- getDynFlags+ let !szb = idSizeCon dflags v+ done instr = do+ let !off = trunc16B $ d - d_v+ return (unitOL (instr off), szb)+ case szb of+ 1 -> done PUSH8+ 2 -> done PUSH16+ 4 -> done PUSH32+ _ -> pushAtom d p (AnnVar v)++pushConstrAtom d p expr = pushAtom d p expr++pushPadding :: Int -> BcM (BCInstrList, ByteOff)+pushPadding 1 = return (unitOL (PUSH_PAD8), 1)+pushPadding 2 = return (unitOL (PUSH_PAD16), 2)+pushPadding 4 = return (unitOL (PUSH_PAD32), 4)+pushPadding x = panic $ "pushPadding x=" ++ show x+ -- ----------------------------------------------------------------------------- -- Given a bunch of alts code and their discrs, do the donkey work -- of making a multiway branch using a switch tree.@@ -1565,12 +1713,15 @@ ppr NoDiscr = text "DEF" -lookupBCEnv_maybe :: Id -> BCEnv -> Maybe Word+lookupBCEnv_maybe :: Id -> BCEnv -> Maybe ByteOff lookupBCEnv_maybe = Map.lookup -idSizeW :: DynFlags -> Id -> Int-idSizeW dflags = argRepSizeW dflags . bcIdArgRep+idSizeW :: DynFlags -> Id -> WordOff+idSizeW dflags = WordOff . argRepSizeW dflags . bcIdArgRep +idSizeCon :: DynFlags -> Id -> ByteOff+idSizeCon dflags = ByteOff . primRepSizeB dflags . bcIdPrimRep+ bcIdArgRep :: Id -> ArgRep bcIdArgRep = toArgRep . bcIdPrimRep @@ -1581,6 +1732,9 @@ | otherwise = pprPanic "bcIdPrimRep" (ppr id <+> dcolon <+> ppr (idType id)) +repSizeWords :: DynFlags -> PrimRep -> WordOff+repSizeWords dflags rep = WordOff $ argRepSizeW dflags (toArgRep rep)+ isFollowableArg :: ArgRep -> Bool isFollowableArg P = True isFollowableArg _ = False@@ -1611,19 +1765,25 @@ ("Error: bytecode compiler can't handle some foreign calling conventions\n"++ " Workaround: use -fobject-code, or compile this module to .o separately.")) -mkSLIDE :: Word16 -> Word -> OrdList BCInstr-mkSLIDE n d- -- if the amount to slide doesn't fit in a word,- -- generate multiple slide instructions- | d > fromIntegral limit- = SLIDE n limit `consOL` mkSLIDE n (d - fromIntegral limit)- | d == 0+mkSlideB :: DynFlags -> ByteOff -> ByteOff -> OrdList BCInstr+mkSlideB dflags !nb !db = mkSlideW n d+ where+ !n = trunc16W $ bytesToWords dflags nb+ !d = bytesToWords dflags db++mkSlideW :: Word16 -> WordOff -> OrdList BCInstr+mkSlideW !n !ws+ | ws > fromIntegral limit+ -- If the amount to slide doesn't fit in a Word16, generate multiple slide+ -- instructions+ = SLIDE n limit `consOL` mkSlideW n (ws - fromIntegral limit)+ | ws == 0 = nilOL | otherwise- = if d == 0 then nilOL else unitOL (SLIDE n $ fromIntegral d)- where- limit :: Word16- limit = maxBound+ = unitOL (SLIDE n $ fromIntegral ws)+ where+ limit :: Word16+ limit = maxBound splitApp :: AnnExpr' Var ann -> (AnnExpr' Var ann, [AnnExpr' Var ann]) -- The arguments are returned in *right-to-left* order@@ -1669,15 +1829,11 @@ atomRep :: AnnExpr' Id ann -> ArgRep atomRep e = toArgRep (atomPrimRep e) -isPtrAtom :: AnnExpr' Id ann -> Bool-isPtrAtom e = isFollowableArg (atomRep e)---- Let szsw be the sizes in words of some items pushed onto the stack,--- which has initial depth d'. Return the values which the stack environment--- should map these items to.-mkStackOffsets :: Word -> [Word] -> [Word]-mkStackOffsets original_depth szsw- = map (subtract 1) (tail (scanl (+) original_depth szsw))+-- | Let szsw be the sizes in bytes of some items pushed onto the stack, which+-- has initial depth @original_depth@. Return the values which the stack+-- environment should map these items to.+mkStackOffsets :: ByteOff -> [ByteOff] -> [ByteOff]+mkStackOffsets original_depth szsb = tail (scanl' (+) original_depth szsb) typeArgRep :: Type -> ArgRep typeArgRep = toArgRep . typePrimRep1
ghci/ByteCodeInstr.hs view
@@ -12,6 +12,8 @@ #include "HsVersions.h" #include "MachDeps.h" +import GhcPrelude+ import ByteCodeTypes import GHCi.RemoteTypes import GHCi.FFI (C_ffi_cif)@@ -30,11 +32,7 @@ import SMRep import Data.Word-#if MIN_VERSION_base(4,9,0) import GHC.Stack.CCS (CostCentre)-#else-import GHC.Stack (CostCentre)-#endif -- ---------------------------------------------------------------------------- -- Bytecode instructions@@ -64,6 +62,23 @@ | PUSH_LL !Word16 !Word16{-2 offsets-} | PUSH_LLL !Word16 !Word16 !Word16{-3 offsets-} + -- Push the specified local as a 8, 16, 32 bit value onto the stack. (i.e.,+ -- the stack will grow by 8, 16 or 32 bits)+ | PUSH8 !Word16+ | PUSH16 !Word16+ | PUSH32 !Word16++ -- Push the specifiec local as a 8, 16, 32 bit value onto the stack, but the+ -- value will take the whole word on the stack (i.e., the stack will gorw by+ -- a word)+ -- This is useful when extracting a packed constructor field for further use.+ -- Currently we expect all values on the stack to take full words, except for+ -- the ones used for PACK (i.e., actually constracting new data types, in+ -- which case we use PUSH{8,16,32})+ | PUSH8_W !Word16+ | PUSH16_W !Word16+ | PUSH32_W !Word16+ -- Push a ptr (these all map to PUSH_G really) | PUSH_G Name | PUSH_PRIMOP PrimOp@@ -73,8 +88,16 @@ | PUSH_ALTS (ProtoBCO Name) | PUSH_ALTS_UNLIFTED (ProtoBCO Name) ArgRep + -- Pushing 8, 16 and 32 bits of padding (for constructors).+ | PUSH_PAD8+ | PUSH_PAD16+ | PUSH_PAD32+ -- Pushing literals- | PUSH_UBX Literal Word16+ | PUSH_UBX8 Literal+ | PUSH_UBX16 Literal+ | PUSH_UBX32 Literal+ | PUSH_UBX Literal Word16 -- push this int/float/double/addr, on the stack. Word16 -- is # of words to copy from literal pool. Eitherness reflects -- the difficulty of dealing with MachAddr here, mostly due to@@ -132,7 +155,11 @@ -- For doing calls to C (via glue code generated by libffi) | CCALL Word16 -- stack frame size (RemotePtr C_ffi_cif) -- addr of the glue code- Word16 -- whether or not the call is interruptible+ Word16 -- flags.+ --+ -- 0x1: call is interruptible+ -- 0x2: call is unsafe+ -- -- (XXX: inefficient, but I don't know -- what the alignment constraints are.) @@ -192,6 +219,12 @@ ppr (PUSH_L offset) = text "PUSH_L " <+> ppr offset ppr (PUSH_LL o1 o2) = text "PUSH_LL " <+> ppr o1 <+> ppr o2 ppr (PUSH_LLL o1 o2 o3) = text "PUSH_LLL" <+> ppr o1 <+> ppr o2 <+> ppr o3+ ppr (PUSH8 offset) = text "PUSH8 " <+> ppr offset+ ppr (PUSH16 offset) = text "PUSH16 " <+> ppr offset+ ppr (PUSH32 offset) = text "PUSH32 " <+> ppr offset+ ppr (PUSH8_W offset) = text "PUSH8_W " <+> ppr offset+ ppr (PUSH16_W offset) = text "PUSH16_W " <+> ppr offset+ ppr (PUSH32_W offset) = text "PUSH32_W " <+> ppr offset ppr (PUSH_G nm) = text "PUSH_G " <+> ppr nm ppr (PUSH_PRIMOP op) = text "PUSH_G " <+> text "GHC.PrimopWrappers." <> ppr op@@ -199,6 +232,13 @@ ppr (PUSH_ALTS bco) = hang (text "PUSH_ALTS") 2 (ppr bco) ppr (PUSH_ALTS_UNLIFTED bco pk) = hang (text "PUSH_ALTS_UNLIFTED" <+> ppr pk) 2 (ppr bco) + ppr PUSH_PAD8 = text "PUSH_PAD8"+ ppr PUSH_PAD16 = text "PUSH_PAD16"+ ppr PUSH_PAD32 = text "PUSH_PAD32"++ ppr (PUSH_UBX8 lit) = text "PUSH_UBX8" <+> ppr lit+ ppr (PUSH_UBX16 lit) = text "PUSH_UBX16" <+> ppr lit+ ppr (PUSH_UBX32 lit) = text "PUSH_UBX32" <+> ppr lit ppr (PUSH_UBX lit nw) = text "PUSH_UBX" <+> parens (ppr nw) <+> ppr lit ppr PUSH_APPLY_N = text "PUSH_APPLY_N" ppr PUSH_APPLY_V = text "PUSH_APPLY_V"@@ -235,12 +275,13 @@ ppr (TESTEQ_P i lab) = text "TESTEQ_P" <+> ppr i <+> text "__" <> ppr lab ppr CASEFAIL = text "CASEFAIL" ppr (JMP lab) = text "JMP" <+> ppr lab- ppr (CCALL off marshall_addr int) = text "CCALL " <+> ppr off+ ppr (CCALL off marshall_addr flags) = text "CCALL " <+> ppr off <+> text "marshall code at" <+> text (show marshall_addr)- <+> (if int == 1- then text "(interruptible)"- else empty)+ <+> (case flags of+ 0x1 -> text "(interruptible)"+ 0x2 -> text "(unsafe)"+ _ -> empty) ppr (SWIZZLE stkoff n) = text "SWIZZLE " <+> text "stkoff" <+> ppr stkoff <+> text "by" <+> ppr n ppr ENTER = text "ENTER"@@ -266,11 +307,23 @@ bciStackUse PUSH_L{} = 1 bciStackUse PUSH_LL{} = 2 bciStackUse PUSH_LLL{} = 3+bciStackUse PUSH8{} = 1 -- overapproximation+bciStackUse PUSH16{} = 1 -- overapproximation+bciStackUse PUSH32{} = 1 -- overapproximation on 64bit arch+bciStackUse PUSH8_W{} = 1 -- takes exactly 1 word+bciStackUse PUSH16_W{} = 1 -- takes exactly 1 word+bciStackUse PUSH32_W{} = 1 -- takes exactly 1 word bciStackUse PUSH_G{} = 1 bciStackUse PUSH_PRIMOP{} = 1 bciStackUse PUSH_BCO{} = 1 bciStackUse (PUSH_ALTS bco) = 2 + protoBCOStackUse bco bciStackUse (PUSH_ALTS_UNLIFTED bco _) = 2 + protoBCOStackUse bco+bciStackUse (PUSH_PAD8) = 1 -- overapproximation+bciStackUse (PUSH_PAD16) = 1 -- overapproximation+bciStackUse (PUSH_PAD32) = 1 -- overapproximation on 64bit arch+bciStackUse (PUSH_UBX8 _) = 1 -- overapproximation+bciStackUse (PUSH_UBX16 _) = 1 -- overapproximation+bciStackUse (PUSH_UBX32 _) = 1 -- overapproximation on 64bit arch bciStackUse (PUSH_UBX _ nw) = fromIntegral nw bciStackUse PUSH_APPLY_N{} = 1 bciStackUse PUSH_APPLY_V{} = 1
ghci/ByteCodeItbls.hs view
@@ -9,6 +9,8 @@ #include "HsVersions.h" +import GhcPrelude+ import ByteCodeTypes import GHCi import DynFlags
ghci/ByteCodeLink.hs view
@@ -19,6 +19,8 @@ #include "HsVersions.h" +import GhcPrelude+ import GHCi.RemoteTypes import GHCi.ResolvedBCO import GHCi.InfoTable@@ -28,7 +30,6 @@ import GHCi import ByteCodeTypes import HscTypes-import DynFlags import Name import NameEnv import PrimOp@@ -40,8 +41,6 @@ -- Standard libraries import Data.Array.Unboxed-import Data.Array.Base-import Data.Word import Foreign.Ptr import GHC.IO ( IO(..) ) import GHC.Exts@@ -69,20 +68,13 @@ -> IO ResolvedBCO linkBCO hsc_env ie ce bco_ix breakarray (UnlinkedBCO _ arity insns bitmap lits0 ptrs0) = do- lits <- mapM (lookupLiteral hsc_env ie) (ssElts lits0)+ -- fromIntegral Word -> Word64 should be a no op if Word is Word64+ -- otherwise it will result in a cast to longlong on 32bit systems.+ lits <- mapM (fmap fromIntegral . lookupLiteral hsc_env ie) (ssElts lits0) ptrs <- mapM (resolvePtr hsc_env ie ce bco_ix breakarray) (ssElts ptrs0)- let dflags = hsc_dflags hsc_env- return (ResolvedBCO arity (toWordArray dflags insns) bitmap+ return (ResolvedBCO isLittleEndian arity insns bitmap (listArray (0, fromIntegral (sizeSS lits0)-1) lits) (addListToSS emptySS ptrs))---- Turn the insns array from a Word16 array into a Word array. The--- latter is much faster to serialize/deserialize. Assumes the input--- array is zero-indexed.-toWordArray :: DynFlags -> UArray Int Word16 -> UArray Int Word-toWordArray dflags (UArray _ _ n arr) = UArray 0 (n'-1) n' arr- where n' = (n + w16s_per_word - 1) `quot` w16s_per_word- w16s_per_word = wORD_SIZE dflags `quot` 2 lookupLiteral :: HscEnv -> ItblEnv -> BCONPtr -> IO Word lookupLiteral _ _ (BCONPtrWord lit) = return lit
ghci/ByteCodeTypes.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, MagicHash, RecordWildCards, GeneralizedNewtypeDeriving #-}+{-# LANGUAGE MagicHash, RecordWildCards, GeneralizedNewtypeDeriving #-} -- -- (c) The University of Glasgow 2002-2006 --@@ -13,6 +13,8 @@ , CCostCentre ) where +import GhcPrelude+ import FastString import Id import Name@@ -34,11 +36,7 @@ import Data.ByteString (ByteString) import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap-#if MIN_VERSION_base(4,9,0) import GHC.Stack.CCS-#else-import GHC.Stack as GHC.Stack.CCS-#endif -- ----------------------------------------------------------------------------- -- Compiled Byte Code@@ -80,7 +78,7 @@ unlinkedBCOName :: !Name, unlinkedBCOArity :: {-# UNPACK #-} !Int, unlinkedBCOInstrs :: !(UArray Int Word16), -- insns- unlinkedBCOBitmap :: !(UArray Int Word), -- bitmap+ unlinkedBCOBitmap :: !(UArray Int Word64), -- bitmap unlinkedBCOLits :: !(SizedSeq BCONPtr), -- non-ptrs unlinkedBCOPtrs :: !(SizedSeq BCOPtr) -- ptrs }
ghci/Debugger.hs view
@@ -14,6 +14,8 @@ module Debugger (pprintClosureCommand, showTerm, pprTypeAndContents) where +import GhcPrelude+ import Linker import RtClosureInspect
ghci/DebuggerUtils.hs view
@@ -4,6 +4,8 @@ dataConInfoPtrToName, ) where +import GhcPrelude+ import GHCi.InfoTable import CmmInfo ( stdInfoTableSizeB ) import DynFlags@@ -110,14 +112,14 @@ -- Warning: this code assumes that the string is well formed. parse :: [Word8] -> ([Word8], [Word8], [Word8]) parse input- = ASSERT(all (>0) (map length [pkg, mod, occ])) (pkg, mod, occ)+ = ASSERT(all (`lengthExceeds` 0) ([pkg, mod, occ])) (pkg, mod, occ) where dot = fromIntegral (ord '.') (pkg, rest1) = break (== fromIntegral (ord ':')) input (mod, occ) = (concat $ intersperse [dot] $ reverse modWords, occWord) where- (modWords, occWord) = ASSERT(length rest1 > 0) (parseModOcc [] (tail rest1))+ (modWords, occWord) = ASSERT(rest1 `lengthExceeds` 0) (parseModOcc [] (tail rest1)) parseModOcc :: [[Word8]] -> [Word8] -> ([[Word8]], [Word8]) -- We only look for dots if str could start with a module name, -- i.e. if it starts with an upper case character.
+ ghci/GHCi.hs view
@@ -0,0 +1,653 @@+{-# LANGUAGE RecordWildCards, ScopedTypeVariables, BangPatterns, CPP #-}++--+-- | Interacting with the interpreter, whether it is running on an+-- external process or in the current process.+--+module GHCi+ ( -- * High-level interface to the interpreter+ evalStmt, EvalStatus_(..), EvalStatus, EvalResult(..), EvalExpr(..)+ , resumeStmt+ , abandonStmt+ , evalIO+ , evalString+ , evalStringToIOString+ , mallocData+ , createBCOs+ , addSptEntry+ , mkCostCentres+ , costCentreStackInfo+ , newBreakArray+ , enableBreakpoint+ , breakpointStatus+ , getBreakpointVar++ -- * The object-code linker+ , initObjLinker+ , lookupSymbol+ , lookupClosure+ , loadDLL+ , loadArchive+ , loadObj+ , unloadObj+ , addLibrarySearchPath+ , removeLibrarySearchPath+ , resolveObjs+ , findSystemLibrary++ -- * Lower-level API using messages+ , iservCmd, Message(..), withIServ, stopIServ+ , iservCall, readIServ, writeIServ+ , purgeLookupSymbolCache+ , freeHValueRefs+ , mkFinalizedHValue+ , wormhole, wormholeRef+ , mkEvalOpts+ , fromEvalResult+ ) where++import GhcPrelude++import GHCi.Message+#if defined(GHCI)+import GHCi.Run+#endif+import GHCi.RemoteTypes+import GHCi.ResolvedBCO+import GHCi.BreakArray (BreakArray)+import Fingerprint+import HscTypes+import UniqFM+import Panic+import DynFlags+import ErrUtils+import Outputable+import Exception+import BasicTypes+import FastString+import Util+import Hooks++import Control.Concurrent+import Control.Monad+import Control.Monad.IO.Class+import Data.Binary+import Data.Binary.Put+import Data.ByteString (ByteString)+import qualified Data.ByteString.Lazy as LB+import Data.IORef+import Foreign hiding (void)+import GHC.Stack.CCS (CostCentre,CostCentreStack)+import System.Exit+import Data.Maybe+import GHC.IO.Handle.Types (Handle)+#if defined(mingw32_HOST_OS)+import Foreign.C+import GHC.IO.Handle.FD (fdToHandle)+#else+import System.Posix as Posix+#endif+import System.Directory+import System.Process+import GHC.Conc (getNumProcessors, pseq, par)++{- Note [Remote GHCi]++When the flag -fexternal-interpreter is given to GHC, interpreted code+is run in a separate process called iserv, and we communicate with the+external process over a pipe using Binary-encoded messages.++Motivation+~~~~~~~~~~++When the interpreted code is running in a separate process, it can+use a different "way", e.g. profiled or dynamic. This means++- compiling Template Haskell code with -prof does not require+ building the code without -prof first++- when GHC itself is profiled, it can interpret unprofiled code,+ and the same applies to dynamic linking.++- An unprofiled GHCi can load and run profiled code, which means it+ can use the stack-trace functionality provided by profiling without+ taking the performance hit on the compiler that profiling would+ entail.++For other reasons see RemoteGHCi on the wiki.++Implementation Overview+~~~~~~~~~~~~~~~~~~~~~~~++The main pieces are:++- libraries/ghci, containing:+ - types for talking about remote values (GHCi.RemoteTypes)+ - the message protocol (GHCi.Message),+ - implementation of the messages (GHCi.Run)+ - implementation of Template Haskell (GHCi.TH)+ - a few other things needed to run interpreted code++- top-level iserv directory, containing the codefor the external+ server. This is a fairly simple wrapper, most of the functionality+ is provided by modules in libraries/ghci.++- This module (GHCi) which provides the interface to the server used+ by the rest of GHC.++GHC works with and without -fexternal-interpreter. With the flag, all+interpreted code is run by the iserv binary. Without the flag,+interpreted code is run in the same process as GHC.++Things that do not work with -fexternal-interpreter+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++dynCompileExpr cannot work, because we have no way to run code of an+unknown type in the remote process. This API fails with an error+message if it is used with -fexternal-interpreter.++Other Notes on Remote GHCi+~~~~~~~~~~~~~~~~~~~~~~~~~~+ * This wiki page has an implementation overview:+ https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/ExternalInterpreter+ * Note [External GHCi pointers] in compiler/ghci/GHCi.hs+ * Note [Remote Template Haskell] in libraries/ghci/GHCi/TH.hs+-}++#if !defined(GHCI)+needExtInt :: IO a+needExtInt = throwIO+ (InstallationError "this operation requires -fexternal-interpreter")+#endif++-- | Run a command in the interpreter's context. With+-- @-fexternal-interpreter@, the command is serialized and sent to an+-- external iserv process, and the response is deserialized (hence the+-- @Binary@ constraint). With @-fno-external-interpreter@ we execute+-- the command directly here.+iservCmd :: Binary a => HscEnv -> Message a -> IO a+iservCmd hsc_env@HscEnv{..} msg+ | gopt Opt_ExternalInterpreter hsc_dflags =+ withIServ hsc_env $ \iserv ->+ uninterruptibleMask_ $ do -- Note [uninterruptibleMask_]+ iservCall iserv msg+ | otherwise = -- Just run it directly+#if defined(GHCI)+ run msg+#else+ needExtInt+#endif++-- Note [uninterruptibleMask_ and iservCmd]+--+-- If we receive an async exception, such as ^C, while communicating+-- with the iserv process then we will be out-of-sync and not be able+-- to recoever. Thus we use uninterruptibleMask_ during+-- communication. A ^C will be delivered to the iserv process (because+-- signals get sent to the whole process group) which will interrupt+-- the running computation and return an EvalException result.++-- | Grab a lock on the 'IServ' and do something with it.+-- Overloaded because this is used from TcM as well as IO.+withIServ+ :: (MonadIO m, ExceptionMonad m)+ => HscEnv -> (IServ -> m a) -> m a+withIServ HscEnv{..} action =+ gmask $ \restore -> do+ m <- liftIO $ takeMVar hsc_iserv+ -- start the iserv process if we haven't done so yet+ iserv <- maybe (liftIO $ startIServ hsc_dflags) return m+ `gonException` (liftIO $ putMVar hsc_iserv Nothing)+ -- free any ForeignHValues that have been garbage collected.+ let iserv' = iserv{ iservPendingFrees = [] }+ a <- (do+ liftIO $ when (not (null (iservPendingFrees iserv))) $+ iservCall iserv (FreeHValueRefs (iservPendingFrees iserv))+ -- run the inner action+ restore $ action iserv)+ `gonException` (liftIO $ putMVar hsc_iserv (Just iserv'))+ liftIO $ putMVar hsc_iserv (Just iserv')+ return a+++-- -----------------------------------------------------------------------------+-- Wrappers around messages++-- | Execute an action of type @IO [a]@, returning 'ForeignHValue's for+-- each of the results.+evalStmt+ :: HscEnv -> Bool -> EvalExpr ForeignHValue+ -> IO (EvalStatus_ [ForeignHValue] [HValueRef])+evalStmt hsc_env step foreign_expr = do+ let dflags = hsc_dflags hsc_env+ status <- withExpr foreign_expr $ \expr ->+ iservCmd hsc_env (EvalStmt (mkEvalOpts dflags step) expr)+ handleEvalStatus hsc_env status+ where+ withExpr :: EvalExpr ForeignHValue -> (EvalExpr HValueRef -> IO a) -> IO a+ withExpr (EvalThis fhv) cont =+ withForeignRef fhv $ \hvref -> cont (EvalThis hvref)+ withExpr (EvalApp fl fr) cont =+ withExpr fl $ \fl' ->+ withExpr fr $ \fr' ->+ cont (EvalApp fl' fr')++resumeStmt+ :: HscEnv -> Bool -> ForeignRef (ResumeContext [HValueRef])+ -> IO (EvalStatus_ [ForeignHValue] [HValueRef])+resumeStmt hsc_env step resume_ctxt = do+ let dflags = hsc_dflags hsc_env+ status <- withForeignRef resume_ctxt $ \rhv ->+ iservCmd hsc_env (ResumeStmt (mkEvalOpts dflags step) rhv)+ handleEvalStatus hsc_env status++abandonStmt :: HscEnv -> ForeignRef (ResumeContext [HValueRef]) -> IO ()+abandonStmt hsc_env resume_ctxt = do+ withForeignRef resume_ctxt $ \rhv ->+ iservCmd hsc_env (AbandonStmt rhv)++handleEvalStatus+ :: HscEnv -> EvalStatus [HValueRef]+ -> IO (EvalStatus_ [ForeignHValue] [HValueRef])+handleEvalStatus hsc_env status =+ case status of+ EvalBreak a b c d e f -> return (EvalBreak a b c d e f)+ EvalComplete alloc res ->+ EvalComplete alloc <$> addFinalizer res+ where+ addFinalizer (EvalException e) = return (EvalException e)+ addFinalizer (EvalSuccess rs) = do+ EvalSuccess <$> mapM (mkFinalizedHValue hsc_env) rs++-- | Execute an action of type @IO ()@+evalIO :: HscEnv -> ForeignHValue -> IO ()+evalIO hsc_env fhv = do+ liftIO $ withForeignRef fhv $ \fhv ->+ iservCmd hsc_env (EvalIO fhv) >>= fromEvalResult++-- | Execute an action of type @IO String@+evalString :: HscEnv -> ForeignHValue -> IO String+evalString hsc_env fhv = do+ liftIO $ withForeignRef fhv $ \fhv ->+ iservCmd hsc_env (EvalString fhv) >>= fromEvalResult++-- | Execute an action of type @String -> IO String@+evalStringToIOString :: HscEnv -> ForeignHValue -> String -> IO String+evalStringToIOString hsc_env fhv str = do+ liftIO $ withForeignRef fhv $ \fhv ->+ iservCmd hsc_env (EvalStringToString fhv str) >>= fromEvalResult+++-- | Allocate and store the given bytes in memory, returning a pointer+-- to the memory in the remote process.+mallocData :: HscEnv -> ByteString -> IO (RemotePtr ())+mallocData hsc_env bs = iservCmd hsc_env (MallocData bs)++mkCostCentres+ :: HscEnv -> String -> [(String,String)] -> IO [RemotePtr CostCentre]+mkCostCentres hsc_env mod ccs =+ iservCmd hsc_env (MkCostCentres mod ccs)++-- | Create a set of BCOs that may be mutually recursive.+createBCOs :: HscEnv -> [ResolvedBCO] -> IO [HValueRef]+createBCOs hsc_env rbcos = do+ n_jobs <- case parMakeCount (hsc_dflags hsc_env) of+ Nothing -> liftIO getNumProcessors+ Just n -> return n+ -- Serializing ResolvedBCO is expensive, so if we're in parallel mode+ -- (-j<n>) parallelise the serialization.+ if (n_jobs == 1)+ then+ iservCmd hsc_env (CreateBCOs [runPut (put rbcos)])++ else do+ old_caps <- getNumCapabilities+ if old_caps == n_jobs+ then void $ evaluate puts+ else bracket_ (setNumCapabilities n_jobs)+ (setNumCapabilities old_caps)+ (void $ evaluate puts)+ iservCmd hsc_env (CreateBCOs puts)+ where+ puts = parMap doChunk (chunkList 100 rbcos)++ -- make sure we force the whole lazy ByteString+ doChunk c = pseq (LB.length bs) bs+ where bs = runPut (put c)++ -- We don't have the parallel package, so roll our own simple parMap+ parMap _ [] = []+ parMap f (x:xs) = fx `par` (fxs `pseq` (fx : fxs))+ where fx = f x; fxs = parMap f xs++addSptEntry :: HscEnv -> Fingerprint -> ForeignHValue -> IO ()+addSptEntry hsc_env fpr ref =+ withForeignRef ref $ \val ->+ iservCmd hsc_env (AddSptEntry fpr val)++costCentreStackInfo :: HscEnv -> RemotePtr CostCentreStack -> IO [String]+costCentreStackInfo hsc_env ccs =+ iservCmd hsc_env (CostCentreStackInfo ccs)++newBreakArray :: HscEnv -> Int -> IO (ForeignRef BreakArray)+newBreakArray hsc_env size = do+ breakArray <- iservCmd hsc_env (NewBreakArray size)+ mkFinalizedHValue hsc_env breakArray++enableBreakpoint :: HscEnv -> ForeignRef BreakArray -> Int -> Bool -> IO ()+enableBreakpoint hsc_env ref ix b = do+ withForeignRef ref $ \breakarray ->+ iservCmd hsc_env (EnableBreakpoint breakarray ix b)++breakpointStatus :: HscEnv -> ForeignRef BreakArray -> Int -> IO Bool+breakpointStatus hsc_env ref ix = do+ withForeignRef ref $ \breakarray ->+ iservCmd hsc_env (BreakpointStatus breakarray ix)++getBreakpointVar :: HscEnv -> ForeignHValue -> Int -> IO (Maybe ForeignHValue)+getBreakpointVar hsc_env ref ix =+ withForeignRef ref $ \apStack -> do+ mb <- iservCmd hsc_env (GetBreakpointVar apStack ix)+ mapM (mkFinalizedHValue hsc_env) mb++-- -----------------------------------------------------------------------------+-- Interface to the object-code linker++initObjLinker :: HscEnv -> IO ()+initObjLinker hsc_env = iservCmd hsc_env InitLinker++lookupSymbol :: HscEnv -> FastString -> IO (Maybe (Ptr ()))+lookupSymbol hsc_env@HscEnv{..} str+ | gopt Opt_ExternalInterpreter hsc_dflags =+ -- Profiling of GHCi showed a lot of time and allocation spent+ -- making cross-process LookupSymbol calls, so I added a GHC-side+ -- cache which sped things up quite a lot. We have to be careful+ -- to purge this cache when unloading code though.+ withIServ hsc_env $ \iserv@IServ{..} -> do+ cache <- readIORef iservLookupSymbolCache+ case lookupUFM cache str of+ Just p -> return (Just p)+ Nothing -> do+ m <- uninterruptibleMask_ $+ iservCall iserv (LookupSymbol (unpackFS str))+ case m of+ Nothing -> return Nothing+ Just r -> do+ let p = fromRemotePtr r+ writeIORef iservLookupSymbolCache $! addToUFM cache str p+ return (Just p)+ | otherwise =+#if defined(GHCI)+ fmap fromRemotePtr <$> run (LookupSymbol (unpackFS str))+#else+ needExtInt+#endif++lookupClosure :: HscEnv -> String -> IO (Maybe HValueRef)+lookupClosure hsc_env str =+ iservCmd hsc_env (LookupClosure str)++purgeLookupSymbolCache :: HscEnv -> IO ()+purgeLookupSymbolCache hsc_env@HscEnv{..} =+ when (gopt Opt_ExternalInterpreter hsc_dflags) $+ withIServ hsc_env $ \IServ{..} ->+ writeIORef iservLookupSymbolCache emptyUFM+++-- | loadDLL loads a dynamic library using the OS's native linker+-- (i.e. dlopen() on Unix, LoadLibrary() on Windows). It takes either+-- an absolute pathname to the file, or a relative filename+-- (e.g. "libfoo.so" or "foo.dll"). In the latter case, loadDLL+-- searches the standard locations for the appropriate library.+--+-- Returns:+--+-- Nothing => success+-- Just err_msg => failure+loadDLL :: HscEnv -> String -> IO (Maybe String)+loadDLL hsc_env str = iservCmd hsc_env (LoadDLL str)++loadArchive :: HscEnv -> String -> IO ()+loadArchive hsc_env path = do+ path' <- canonicalizePath path -- Note [loadObj and relative paths]+ iservCmd hsc_env (LoadArchive path')++loadObj :: HscEnv -> String -> IO ()+loadObj hsc_env path = do+ path' <- canonicalizePath path -- Note [loadObj and relative paths]+ iservCmd hsc_env (LoadObj path')++unloadObj :: HscEnv -> String -> IO ()+unloadObj hsc_env path = do+ path' <- canonicalizePath path -- Note [loadObj and relative paths]+ iservCmd hsc_env (UnloadObj path')++-- Note [loadObj and relative paths]+-- the iserv process might have a different current directory from the+-- GHC process, so we must make paths absolute before sending them+-- over.++addLibrarySearchPath :: HscEnv -> String -> IO (Ptr ())+addLibrarySearchPath hsc_env str =+ fromRemotePtr <$> iservCmd hsc_env (AddLibrarySearchPath str)++removeLibrarySearchPath :: HscEnv -> Ptr () -> IO Bool+removeLibrarySearchPath hsc_env p =+ iservCmd hsc_env (RemoveLibrarySearchPath (toRemotePtr p))++resolveObjs :: HscEnv -> IO SuccessFlag+resolveObjs hsc_env = successIf <$> iservCmd hsc_env ResolveObjs++findSystemLibrary :: HscEnv -> String -> IO (Maybe String)+findSystemLibrary hsc_env str = iservCmd hsc_env (FindSystemLibrary str)+++-- -----------------------------------------------------------------------------+-- Raw calls and messages++-- | Send a 'Message' and receive the response from the iserv process+iservCall :: Binary a => IServ -> Message a -> IO a+iservCall iserv@IServ{..} msg =+ remoteCall iservPipe msg+ `catch` \(e :: SomeException) -> handleIServFailure iserv e++-- | Read a value from the iserv process+readIServ :: IServ -> Get a -> IO a+readIServ iserv@IServ{..} get =+ readPipe iservPipe get+ `catch` \(e :: SomeException) -> handleIServFailure iserv e++-- | Send a value to the iserv process+writeIServ :: IServ -> Put -> IO ()+writeIServ iserv@IServ{..} put =+ writePipe iservPipe put+ `catch` \(e :: SomeException) -> handleIServFailure iserv e++handleIServFailure :: IServ -> SomeException -> IO a+handleIServFailure IServ{..} e = do+ ex <- getProcessExitCode iservProcess+ case ex of+ Just (ExitFailure n) ->+ throw (InstallationError ("ghc-iserv terminated (" ++ show n ++ ")"))+ _ -> do+ terminateProcess iservProcess+ _ <- waitForProcess iservProcess+ throw e++-- -----------------------------------------------------------------------------+-- Starting and stopping the iserv process++startIServ :: DynFlags -> IO IServ+startIServ dflags = do+ let flavour+ | WayProf `elem` ways dflags = "-prof"+ | WayDyn `elem` ways dflags = "-dyn"+ | otherwise = ""+ prog = pgm_i dflags ++ flavour+ opts = getOpts dflags opt_i+ debugTraceMsg dflags 3 $ text "Starting " <> text prog+ let createProc = lookupHook createIservProcessHook+ (\cp -> do { (_,_,_,ph) <- createProcess cp+ ; return ph })+ dflags+ (ph, rh, wh) <- runWithPipes createProc prog opts+ lo_ref <- newIORef Nothing+ cache_ref <- newIORef emptyUFM+ return $ IServ+ { iservPipe = Pipe { pipeRead = rh+ , pipeWrite = wh+ , pipeLeftovers = lo_ref }+ , iservProcess = ph+ , iservLookupSymbolCache = cache_ref+ , iservPendingFrees = []+ }++stopIServ :: HscEnv -> IO ()+stopIServ HscEnv{..} =+ gmask $ \_restore -> do+ m <- takeMVar hsc_iserv+ maybe (return ()) stop m+ putMVar hsc_iserv Nothing+ where+ stop iserv = do+ ex <- getProcessExitCode (iservProcess iserv)+ if isJust ex+ then return ()+ else iservCall iserv Shutdown++runWithPipes :: (CreateProcess -> IO ProcessHandle)+ -> FilePath -> [String] -> IO (ProcessHandle, Handle, Handle)+#if defined(mingw32_HOST_OS)+foreign import ccall "io.h _close"+ c__close :: CInt -> IO CInt++foreign import ccall unsafe "io.h _get_osfhandle"+ _get_osfhandle :: CInt -> IO CInt++runWithPipes createProc prog opts = do+ (rfd1, wfd1) <- createPipeFd -- we read on rfd1+ (rfd2, wfd2) <- createPipeFd -- we write on wfd2+ wh_client <- _get_osfhandle wfd1+ rh_client <- _get_osfhandle rfd2+ let args = show wh_client : show rh_client : opts+ ph <- createProc (proc prog args)+ rh <- mkHandle rfd1+ wh <- mkHandle wfd2+ return (ph, rh, wh)+ where mkHandle :: CInt -> IO Handle+ mkHandle fd = (fdToHandle fd) `onException` (c__close fd)++#else+runWithPipes createProc prog opts = do+ (rfd1, wfd1) <- Posix.createPipe -- we read on rfd1+ (rfd2, wfd2) <- Posix.createPipe -- we write on wfd2+ setFdOption rfd1 CloseOnExec True+ setFdOption wfd2 CloseOnExec True+ let args = show wfd1 : show rfd2 : opts+ ph <- createProc (proc prog args)+ closeFd wfd1+ closeFd rfd2+ rh <- fdToHandle rfd1+ wh <- fdToHandle wfd2+ return (ph, rh, wh)+#endif++-- -----------------------------------------------------------------------------+{- Note [External GHCi pointers]++We have the following ways to reference things in GHCi:++HValue+------++HValue is a direct reference to a value in the local heap. Obviously+we cannot use this to refer to things in the external process.+++RemoteRef+---------++RemoteRef is a StablePtr to a heap-resident value. When+-fexternal-interpreter is used, this value resides in the external+process's heap. RemoteRefs are mostly used to send pointers in+messages between GHC and iserv.++A RemoteRef must be explicitly freed when no longer required, using+freeHValueRefs, or by attaching a finalizer with mkForeignHValue.++To get from a RemoteRef to an HValue you can use 'wormholeRef', which+fails with an error message if -fexternal-interpreter is in use.++ForeignRef+----------++A ForeignRef is a RemoteRef with a finalizer that will free the+'RemoteRef' when it is garbage collected. We mostly use ForeignHValue+on the GHC side.++The finalizer adds the RemoteRef to the iservPendingFrees list in the+IServ record. The next call to iservCmd will free any RemoteRefs in+the list. It was done this way rather than calling iservCmd directly,+because I didn't want to have arbitrary threads calling iservCmd. In+principle it would probably be ok, but it seems less hairy this way.+-}++-- | Creates a 'ForeignRef' that will automatically release the+-- 'RemoteRef' when it is no longer referenced.+mkFinalizedHValue :: HscEnv -> RemoteRef a -> IO (ForeignRef a)+mkFinalizedHValue HscEnv{..} rref = mkForeignRef rref free+ where+ !external = gopt Opt_ExternalInterpreter hsc_dflags+ hvref = toHValueRef rref++ free :: IO ()+ free+ | not external = freeRemoteRef hvref+ | otherwise =+ modifyMVar_ hsc_iserv $ \mb_iserv ->+ case mb_iserv of+ Nothing -> return Nothing -- already shut down+ Just iserv@IServ{..} ->+ return (Just iserv{iservPendingFrees = hvref : iservPendingFrees})++freeHValueRefs :: HscEnv -> [HValueRef] -> IO ()+freeHValueRefs _ [] = return ()+freeHValueRefs hsc_env refs = iservCmd hsc_env (FreeHValueRefs refs)++-- | Convert a 'ForeignRef' to the value it references directly. This+-- only works when the interpreter is running in the same process as+-- the compiler, so it fails when @-fexternal-interpreter@ is on.+wormhole :: DynFlags -> ForeignRef a -> IO a+wormhole dflags r = wormholeRef dflags (unsafeForeignRefToRemoteRef r)++-- | Convert an 'RemoteRef' to the value it references directly. This+-- only works when the interpreter is running in the same process as+-- the compiler, so it fails when @-fexternal-interpreter@ is on.+wormholeRef :: DynFlags -> RemoteRef a -> IO a+wormholeRef dflags _r+ | gopt Opt_ExternalInterpreter dflags+ = throwIO (InstallationError+ "this operation requires -fno-external-interpreter")+#if defined(GHCI)+ | otherwise+ = localRef _r+#else+ | otherwise+ = throwIO (InstallationError+ "can't wormhole a value in a stage1 compiler")+#endif++-- -----------------------------------------------------------------------------+-- Misc utils++mkEvalOpts :: DynFlags -> Bool -> EvalOpts+mkEvalOpts dflags step =+ EvalOpts+ { useSandboxThread = gopt Opt_GhciSandbox dflags+ , singleStep = step+ , breakOnException = gopt Opt_BreakOnException dflags+ , breakOnError = gopt Opt_BreakOnError dflags }++fromEvalResult :: EvalResult a -> IO a+fromEvalResult (EvalException e) = throwIO (fromSerializableException e)+fromEvalResult (EvalSuccess a) = return a
− ghci/GHCi.hsc
@@ -1,677 +0,0 @@-{-# LANGUAGE RecordWildCards, ScopedTypeVariables, BangPatterns, CPP #-}------- | Interacting with the interpreter, whether it is running on an--- external process or in the current process.----module GHCi- ( -- * High-level interface to the interpreter- evalStmt, EvalStatus_(..), EvalStatus, EvalResult(..), EvalExpr(..)- , resumeStmt- , abandonStmt- , evalIO- , evalString- , evalStringToIOString- , mallocData- , createBCOs- , addSptEntry- , mkCostCentres- , costCentreStackInfo- , newBreakArray- , enableBreakpoint- , breakpointStatus- , getBreakpointVar-- -- * The object-code linker- , initObjLinker- , lookupSymbol- , lookupClosure- , loadDLL- , loadArchive- , loadObj- , unloadObj- , addLibrarySearchPath- , removeLibrarySearchPath- , resolveObjs- , findSystemLibrary-- -- * Lower-level API using messages- , iservCmd, Message(..), withIServ, stopIServ- , iservCall, readIServ, writeIServ- , purgeLookupSymbolCache- , freeHValueRefs- , mkFinalizedHValue- , wormhole, wormholeRef- , mkEvalOpts- , fromEvalResult- ) where--import GHCi.Message-#ifdef GHCI-import GHCi.Run-#endif-import GHCi.RemoteTypes-import GHCi.ResolvedBCO-import GHCi.BreakArray (BreakArray)-import Fingerprint-import HscTypes-import UniqFM-import Panic-import DynFlags-import ErrUtils-import Outputable-import Exception-import BasicTypes-import FastString-import Util-import Hooks--import Control.Concurrent-import Control.Monad-import Control.Monad.IO.Class-import Data.Binary-import Data.Binary.Put-import Data.ByteString (ByteString)-import qualified Data.ByteString.Lazy as LB-import Data.IORef-import Foreign hiding (void)-#if MIN_VERSION_base(4,9,0)-import GHC.Stack.CCS (CostCentre,CostCentreStack)-#else-import GHC.Stack (CostCentre,CostCentreStack)-#endif-import System.Exit-import Data.Maybe-import GHC.IO.Handle.Types (Handle)-#ifdef mingw32_HOST_OS-import Foreign.C-import GHC.IO.Handle.FD (fdToHandle)-#if !MIN_VERSION_process(1,4,2)-import System.Posix.Internals-import Foreign.Marshal.Array-import Foreign.C.Error-import Foreign.Storable-#endif-#else-import System.Posix as Posix-#endif-import System.Directory-import System.Process-import GHC.Conc (getNumProcessors, pseq, par)--{- Note [Remote GHCi]--When the flag -fexternal-interpreter is given to GHC, interpreted code-is run in a separate process called iserv, and we communicate with the-external process over a pipe using Binary-encoded messages.--Motivation-~~~~~~~~~~--When the interpreted code is running in a separate process, it can-use a different "way", e.g. profiled or dynamic. This means--- compiling Template Haskell code with -prof does not require- building the code without -prof first--- when GHC itself is profiled, it can interpret unprofiled code,- and the same applies to dynamic linking.--- An unprofiled GHCi can load and run profiled code, which means it- can use the stack-trace functionality provided by profiling without- taking the performance hit on the compiler that profiling would- entail.--For other reasons see RemoteGHCi on the wiki.--Implementation Overview-~~~~~~~~~~~~~~~~~~~~~~~--The main pieces are:--- libraries/ghci, containing:- - types for talking about remote values (GHCi.RemoteTypes)- - the message protocol (GHCi.Message),- - implementation of the messages (GHCi.Run)- - implementation of Template Haskell (GHCi.TH)- - a few other things needed to run interpreted code--- top-level iserv directory, containing the codefor the external- server. This is a fairly simple wrapper, most of the functionality- is provided by modules in libraries/ghci.--- This module (GHCi) which provides the interface to the server used- by the rest of GHC.--GHC works with and without -fexternal-interpreter. With the flag, all-interpreted code is run by the iserv binary. Without the flag,-interpreted code is run in the same process as GHC.--Things that do not work with -fexternal-interpreter-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--dynCompileExpr cannot work, because we have no way to run code of an-unknown type in the remote process. This API fails with an error-message if it is used with -fexternal-interpreter.--Other Notes on Remote GHCi-~~~~~~~~~~~~~~~~~~~~~~~~~~- * This wiki page has an implementation overview:- https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/ExternalInterpreter- * Note [External GHCi pointers] in compiler/ghci/GHCi.hs- * Note [Remote Template Haskell] in libraries/ghci/GHCi/TH.hs--}--#ifndef GHCI-needExtInt :: IO a-needExtInt = throwIO- (InstallationError "this operation requires -fexternal-interpreter")-#endif---- | Run a command in the interpreter's context. With--- @-fexternal-interpreter@, the command is serialized and sent to an--- external iserv process, and the response is deserialized (hence the--- @Binary@ constraint). With @-fno-external-interpreter@ we execute--- the command directly here.-iservCmd :: Binary a => HscEnv -> Message a -> IO a-iservCmd hsc_env@HscEnv{..} msg- | gopt Opt_ExternalInterpreter hsc_dflags =- withIServ hsc_env $ \iserv ->- uninterruptibleMask_ $ do -- Note [uninterruptibleMask_]- iservCall iserv msg- | otherwise = -- Just run it directly-#ifdef GHCI- run msg-#else- needExtInt-#endif---- Note [uninterruptibleMask_ and iservCmd]------ If we receive an async exception, such as ^C, while communicating--- with the iserv process then we will be out-of-sync and not be able--- to recoever. Thus we use uninterruptibleMask_ during--- communication. A ^C will be delivered to the iserv process (because--- signals get sent to the whole process group) which will interrupt--- the running computation and return an EvalException result.---- | Grab a lock on the 'IServ' and do something with it.--- Overloaded because this is used from TcM as well as IO.-withIServ- :: (MonadIO m, ExceptionMonad m)- => HscEnv -> (IServ -> m a) -> m a-withIServ HscEnv{..} action =- gmask $ \restore -> do- m <- liftIO $ takeMVar hsc_iserv- -- start the iserv process if we haven't done so yet- iserv <- maybe (liftIO $ startIServ hsc_dflags) return m- `gonException` (liftIO $ putMVar hsc_iserv Nothing)- -- free any ForeignHValues that have been garbage collected.- let iserv' = iserv{ iservPendingFrees = [] }- a <- (do- liftIO $ when (not (null (iservPendingFrees iserv))) $- iservCall iserv (FreeHValueRefs (iservPendingFrees iserv))- -- run the inner action- restore $ action iserv)- `gonException` (liftIO $ putMVar hsc_iserv (Just iserv'))- liftIO $ putMVar hsc_iserv (Just iserv')- return a----- -------------------------------------------------------------------------------- Wrappers around messages---- | Execute an action of type @IO [a]@, returning 'ForeignHValue's for--- each of the results.-evalStmt- :: HscEnv -> Bool -> EvalExpr ForeignHValue- -> IO (EvalStatus_ [ForeignHValue] [HValueRef])-evalStmt hsc_env step foreign_expr = do- let dflags = hsc_dflags hsc_env- status <- withExpr foreign_expr $ \expr ->- iservCmd hsc_env (EvalStmt (mkEvalOpts dflags step) expr)- handleEvalStatus hsc_env status- where- withExpr :: EvalExpr ForeignHValue -> (EvalExpr HValueRef -> IO a) -> IO a- withExpr (EvalThis fhv) cont =- withForeignRef fhv $ \hvref -> cont (EvalThis hvref)- withExpr (EvalApp fl fr) cont =- withExpr fl $ \fl' ->- withExpr fr $ \fr' ->- cont (EvalApp fl' fr')--resumeStmt- :: HscEnv -> Bool -> ForeignRef (ResumeContext [HValueRef])- -> IO (EvalStatus_ [ForeignHValue] [HValueRef])-resumeStmt hsc_env step resume_ctxt = do- let dflags = hsc_dflags hsc_env- status <- withForeignRef resume_ctxt $ \rhv ->- iservCmd hsc_env (ResumeStmt (mkEvalOpts dflags step) rhv)- handleEvalStatus hsc_env status--abandonStmt :: HscEnv -> ForeignRef (ResumeContext [HValueRef]) -> IO ()-abandonStmt hsc_env resume_ctxt = do- withForeignRef resume_ctxt $ \rhv ->- iservCmd hsc_env (AbandonStmt rhv)--handleEvalStatus- :: HscEnv -> EvalStatus [HValueRef]- -> IO (EvalStatus_ [ForeignHValue] [HValueRef])-handleEvalStatus hsc_env status =- case status of- EvalBreak a b c d e f -> return (EvalBreak a b c d e f)- EvalComplete alloc res ->- EvalComplete alloc <$> addFinalizer res- where- addFinalizer (EvalException e) = return (EvalException e)- addFinalizer (EvalSuccess rs) = do- EvalSuccess <$> mapM (mkFinalizedHValue hsc_env) rs---- | Execute an action of type @IO ()@-evalIO :: HscEnv -> ForeignHValue -> IO ()-evalIO hsc_env fhv = do- liftIO $ withForeignRef fhv $ \fhv ->- iservCmd hsc_env (EvalIO fhv) >>= fromEvalResult---- | Execute an action of type @IO String@-evalString :: HscEnv -> ForeignHValue -> IO String-evalString hsc_env fhv = do- liftIO $ withForeignRef fhv $ \fhv ->- iservCmd hsc_env (EvalString fhv) >>= fromEvalResult---- | Execute an action of type @String -> IO String@-evalStringToIOString :: HscEnv -> ForeignHValue -> String -> IO String-evalStringToIOString hsc_env fhv str = do- liftIO $ withForeignRef fhv $ \fhv ->- iservCmd hsc_env (EvalStringToString fhv str) >>= fromEvalResult----- | Allocate and store the given bytes in memory, returning a pointer--- to the memory in the remote process.-mallocData :: HscEnv -> ByteString -> IO (RemotePtr ())-mallocData hsc_env bs = iservCmd hsc_env (MallocData bs)--mkCostCentres- :: HscEnv -> String -> [(String,String)] -> IO [RemotePtr CostCentre]-mkCostCentres hsc_env mod ccs =- iservCmd hsc_env (MkCostCentres mod ccs)---- | Create a set of BCOs that may be mutually recursive.-createBCOs :: HscEnv -> [ResolvedBCO] -> IO [HValueRef]-createBCOs hsc_env rbcos = do- n_jobs <- case parMakeCount (hsc_dflags hsc_env) of- Nothing -> liftIO getNumProcessors- Just n -> return n- -- Serializing ResolvedBCO is expensive, so if we're in parallel mode- -- (-j<n>) parallelise the serialization.- if (n_jobs == 1)- then- iservCmd hsc_env (CreateBCOs [runPut (put rbcos)])-- else do- old_caps <- getNumCapabilities- if old_caps == n_jobs- then void $ evaluate puts- else bracket_ (setNumCapabilities n_jobs)- (setNumCapabilities old_caps)- (void $ evaluate puts)- iservCmd hsc_env (CreateBCOs puts)- where- puts = parMap doChunk (chunkList 100 rbcos)-- -- make sure we force the whole lazy ByteString- doChunk c = pseq (LB.length bs) bs- where bs = runPut (put c)-- -- We don't have the parallel package, so roll our own simple parMap- parMap _ [] = []- parMap f (x:xs) = fx `par` (fxs `pseq` (fx : fxs))- where fx = f x; fxs = parMap f xs--addSptEntry :: HscEnv -> Fingerprint -> ForeignHValue -> IO ()-addSptEntry hsc_env fpr ref =- withForeignRef ref $ \val ->- iservCmd hsc_env (AddSptEntry fpr val)--costCentreStackInfo :: HscEnv -> RemotePtr CostCentreStack -> IO [String]-costCentreStackInfo hsc_env ccs =- iservCmd hsc_env (CostCentreStackInfo ccs)--newBreakArray :: HscEnv -> Int -> IO (ForeignRef BreakArray)-newBreakArray hsc_env size = do- breakArray <- iservCmd hsc_env (NewBreakArray size)- mkFinalizedHValue hsc_env breakArray--enableBreakpoint :: HscEnv -> ForeignRef BreakArray -> Int -> Bool -> IO ()-enableBreakpoint hsc_env ref ix b = do- withForeignRef ref $ \breakarray ->- iservCmd hsc_env (EnableBreakpoint breakarray ix b)--breakpointStatus :: HscEnv -> ForeignRef BreakArray -> Int -> IO Bool-breakpointStatus hsc_env ref ix = do- withForeignRef ref $ \breakarray ->- iservCmd hsc_env (BreakpointStatus breakarray ix)--getBreakpointVar :: HscEnv -> ForeignHValue -> Int -> IO (Maybe ForeignHValue)-getBreakpointVar hsc_env ref ix =- withForeignRef ref $ \apStack -> do- mb <- iservCmd hsc_env (GetBreakpointVar apStack ix)- mapM (mkFinalizedHValue hsc_env) mb---- -------------------------------------------------------------------------------- Interface to the object-code linker--initObjLinker :: HscEnv -> IO ()-initObjLinker hsc_env = iservCmd hsc_env InitLinker--lookupSymbol :: HscEnv -> FastString -> IO (Maybe (Ptr ()))-lookupSymbol hsc_env@HscEnv{..} str- | gopt Opt_ExternalInterpreter hsc_dflags =- -- Profiling of GHCi showed a lot of time and allocation spent- -- making cross-process LookupSymbol calls, so I added a GHC-side- -- cache which sped things up quite a lot. We have to be careful- -- to purge this cache when unloading code though.- withIServ hsc_env $ \iserv@IServ{..} -> do- cache <- readIORef iservLookupSymbolCache- case lookupUFM cache str of- Just p -> return (Just p)- Nothing -> do- m <- uninterruptibleMask_ $- iservCall iserv (LookupSymbol (unpackFS str))- case m of- Nothing -> return Nothing- Just r -> do- let p = fromRemotePtr r- writeIORef iservLookupSymbolCache $! addToUFM cache str p- return (Just p)- | otherwise =-#ifdef GHCI- fmap fromRemotePtr <$> run (LookupSymbol (unpackFS str))-#else- needExtInt-#endif--lookupClosure :: HscEnv -> String -> IO (Maybe HValueRef)-lookupClosure hsc_env str =- iservCmd hsc_env (LookupClosure str)--purgeLookupSymbolCache :: HscEnv -> IO ()-purgeLookupSymbolCache hsc_env@HscEnv{..} =- when (gopt Opt_ExternalInterpreter hsc_dflags) $- withIServ hsc_env $ \IServ{..} ->- writeIORef iservLookupSymbolCache emptyUFM----- | loadDLL loads a dynamic library using the OS's native linker--- (i.e. dlopen() on Unix, LoadLibrary() on Windows). It takes either--- an absolute pathname to the file, or a relative filename--- (e.g. "libfoo.so" or "foo.dll"). In the latter case, loadDLL--- searches the standard locations for the appropriate library.------ Returns:------ Nothing => success--- Just err_msg => failure-loadDLL :: HscEnv -> String -> IO (Maybe String)-loadDLL hsc_env str = iservCmd hsc_env (LoadDLL str)--loadArchive :: HscEnv -> String -> IO ()-loadArchive hsc_env path = do- path' <- canonicalizePath path -- Note [loadObj and relative paths]- iservCmd hsc_env (LoadArchive path')--loadObj :: HscEnv -> String -> IO ()-loadObj hsc_env path = do- path' <- canonicalizePath path -- Note [loadObj and relative paths]- iservCmd hsc_env (LoadObj path')--unloadObj :: HscEnv -> String -> IO ()-unloadObj hsc_env path = do- path' <- canonicalizePath path -- Note [loadObj and relative paths]- iservCmd hsc_env (UnloadObj path')---- Note [loadObj and relative paths]--- the iserv process might have a different current directory from the--- GHC process, so we must make paths absolute before sending them--- over.--addLibrarySearchPath :: HscEnv -> String -> IO (Ptr ())-addLibrarySearchPath hsc_env str =- fromRemotePtr <$> iservCmd hsc_env (AddLibrarySearchPath str)--removeLibrarySearchPath :: HscEnv -> Ptr () -> IO Bool-removeLibrarySearchPath hsc_env p =- iservCmd hsc_env (RemoveLibrarySearchPath (toRemotePtr p))--resolveObjs :: HscEnv -> IO SuccessFlag-resolveObjs hsc_env = successIf <$> iservCmd hsc_env ResolveObjs--findSystemLibrary :: HscEnv -> String -> IO (Maybe String)-findSystemLibrary hsc_env str = iservCmd hsc_env (FindSystemLibrary str)----- -------------------------------------------------------------------------------- Raw calls and messages---- | Send a 'Message' and receive the response from the iserv process-iservCall :: Binary a => IServ -> Message a -> IO a-iservCall iserv@IServ{..} msg =- remoteCall iservPipe msg- `catch` \(e :: SomeException) -> handleIServFailure iserv e---- | Read a value from the iserv process-readIServ :: IServ -> Get a -> IO a-readIServ iserv@IServ{..} get =- readPipe iservPipe get- `catch` \(e :: SomeException) -> handleIServFailure iserv e---- | Send a value to the iserv process-writeIServ :: IServ -> Put -> IO ()-writeIServ iserv@IServ{..} put =- writePipe iservPipe put- `catch` \(e :: SomeException) -> handleIServFailure iserv e--handleIServFailure :: IServ -> SomeException -> IO a-handleIServFailure IServ{..} e = do- ex <- getProcessExitCode iservProcess- case ex of- Just (ExitFailure n) ->- throw (InstallationError ("ghc-iserv terminated (" ++ show n ++ ")"))- _ -> do- terminateProcess iservProcess- _ <- waitForProcess iservProcess- throw e---- -------------------------------------------------------------------------------- Starting and stopping the iserv process--startIServ :: DynFlags -> IO IServ-startIServ dflags = do- let flavour- | WayProf `elem` ways dflags = "-prof"- | WayDyn `elem` ways dflags = "-dyn"- | otherwise = ""- prog = pgm_i dflags ++ flavour- opts = getOpts dflags opt_i- debugTraceMsg dflags 3 $ text "Starting " <> text prog- let createProc = lookupHook createIservProcessHook- (\cp -> do { (_,_,_,ph) <- createProcess cp- ; return ph })- dflags- (ph, rh, wh) <- runWithPipes createProc prog opts- lo_ref <- newIORef Nothing- cache_ref <- newIORef emptyUFM- return $ IServ- { iservPipe = Pipe { pipeRead = rh- , pipeWrite = wh- , pipeLeftovers = lo_ref }- , iservProcess = ph- , iservLookupSymbolCache = cache_ref- , iservPendingFrees = []- }--stopIServ :: HscEnv -> IO ()-stopIServ HscEnv{..} =- gmask $ \_restore -> do- m <- takeMVar hsc_iserv- maybe (return ()) stop m- putMVar hsc_iserv Nothing- where- stop iserv = do- ex <- getProcessExitCode (iservProcess iserv)- if isJust ex- then return ()- else iservCall iserv Shutdown--runWithPipes :: (CreateProcess -> IO ProcessHandle)- -> FilePath -> [String] -> IO (ProcessHandle, Handle, Handle)-#ifdef mingw32_HOST_OS-foreign import ccall "io.h _close"- c__close :: CInt -> IO CInt--foreign import ccall unsafe "io.h _get_osfhandle"- _get_osfhandle :: CInt -> IO CInt--runWithPipes createProc prog opts = do- (rfd1, wfd1) <- createPipeFd -- we read on rfd1- (rfd2, wfd2) <- createPipeFd -- we write on wfd2- wh_client <- _get_osfhandle wfd1- rh_client <- _get_osfhandle rfd2- let args = show wh_client : show rh_client : opts- ph <- createProc (proc prog args)- rh <- mkHandle rfd1- wh <- mkHandle wfd2- return (ph, rh, wh)- where mkHandle :: CInt -> IO Handle- mkHandle fd = (fdToHandle fd) `onException` (c__close fd)--#if !MIN_VERSION_process(1,4,2)--- This #include and the _O_BINARY below are the only reason this is hsc,--- so we can remove that once we can depend on process 1.4.2-#include <fcntl.h>--createPipeFd :: IO (FD, FD)-createPipeFd = do- allocaArray 2 $ \ pfds -> do- throwErrnoIfMinus1_ "_pipe" $ c__pipe pfds 2 (#const _O_BINARY)- readfd <- peek pfds- writefd <- peekElemOff pfds 1- return (readfd, writefd)--foreign import ccall "io.h _pipe" c__pipe ::- Ptr CInt -> CUInt -> CInt -> IO CInt-#endif-#else-runWithPipes createProc prog opts = do- (rfd1, wfd1) <- Posix.createPipe -- we read on rfd1- (rfd2, wfd2) <- Posix.createPipe -- we write on wfd2- setFdOption rfd1 CloseOnExec True- setFdOption wfd2 CloseOnExec True- let args = show wfd1 : show rfd2 : opts- ph <- createProc (proc prog args)- closeFd wfd1- closeFd rfd2- rh <- fdToHandle rfd1- wh <- fdToHandle wfd2- return (ph, rh, wh)-#endif---- ------------------------------------------------------------------------------{- Note [External GHCi pointers]--We have the following ways to reference things in GHCi:--HValue---------HValue is a direct reference to an value in the local heap. Obviously-we cannot use this to refer to things in the external process.---RemoteRef------------RemoteRef is a StablePtr to a heap-resident value. When--fexternal-interpreter is used, this value resides in the external-process's heap. RemoteRefs are mostly used to send pointers in-messages between GHC and iserv.--A RemoteRef must be explicitly freed when no longer required, using-freeHValueRefs, or by attaching a finalizer with mkForeignHValue.--To get from a RemoteRef to an HValue you can use 'wormholeRef', which-fails with an error message if -fexternal-interpreter is in use.--ForeignRef-------------A ForeignRef is a RemoteRef with a finalizer that will free the-'RemoteRef' when it is garbage collected. We mostly use ForeignHValue-on the GHC side.--The finalizer adds the RemoteRef to the iservPendingFrees list in the-IServ record. The next call to iservCmd will free any RemoteRefs in-the list. It was done this way rather than calling iservCmd directly,-because I didn't want to have arbitrary threads calling iservCmd. In-principle it would probably be ok, but it seems less hairy this way.--}---- | Creates a 'ForeignRef' that will automatically release the--- 'RemoteRef' when it is no longer referenced.-mkFinalizedHValue :: HscEnv -> RemoteRef a -> IO (ForeignRef a)-mkFinalizedHValue HscEnv{..} rref = mkForeignRef rref free- where- !external = gopt Opt_ExternalInterpreter hsc_dflags- hvref = toHValueRef rref-- free :: IO ()- free- | not external = freeRemoteRef hvref- | otherwise =- modifyMVar_ hsc_iserv $ \mb_iserv ->- case mb_iserv of- Nothing -> return Nothing -- already shut down- Just iserv@IServ{..} ->- return (Just iserv{iservPendingFrees = hvref : iservPendingFrees})--freeHValueRefs :: HscEnv -> [HValueRef] -> IO ()-freeHValueRefs _ [] = return ()-freeHValueRefs hsc_env refs = iservCmd hsc_env (FreeHValueRefs refs)---- | Convert a 'ForeignRef' to the value it references directly. This--- only works when the interpreter is running in the same process as--- the compiler, so it fails when @-fexternal-interpreter@ is on.-wormhole :: DynFlags -> ForeignRef a -> IO a-wormhole dflags r = wormholeRef dflags (unsafeForeignRefToRemoteRef r)---- | Convert an 'RemoteRef' to the value it references directly. This--- only works when the interpreter is running in the same process as--- the compiler, so it fails when @-fexternal-interpreter@ is on.-wormholeRef :: DynFlags -> RemoteRef a -> IO a-wormholeRef dflags _r- | gopt Opt_ExternalInterpreter dflags- = throwIO (InstallationError- "this operation requires -fno-external-interpreter")-#ifdef GHCI- | otherwise- = localRef _r-#else- | otherwise- = throwIO (InstallationError- "can't wormhole a value in a stage1 compiler")-#endif---- -------------------------------------------------------------------------------- Misc utils--mkEvalOpts :: DynFlags -> Bool -> EvalOpts-mkEvalOpts dflags step =- EvalOpts- { useSandboxThread = gopt Opt_GhciSandbox dflags- , singleStep = step- , breakOnException = gopt Opt_BreakOnException dflags- , breakOnError = gopt Opt_BreakOnError dflags }--fromEvalResult :: EvalResult a -> IO a-fromEvalResult (EvalException e) = throwIO (fromSerializableException e)-fromEvalResult (EvalSuccess a) = return a
ghci/Linker.hs view
@@ -20,6 +20,8 @@ #include "HsVersions.h" +import GhcPrelude+ import GHCi import GHCi.RemoteTypes import LoadIface@@ -47,11 +49,12 @@ import FastString import Platform import SysTools+import FileCleanup -- Standard libraries import Control.Monad-import Control.Applicative((<|>)) +import Data.Char (isSpace) import Data.IORef import Data.List import Data.Maybe@@ -59,7 +62,12 @@ import System.FilePath import System.Directory+import System.IO.Unsafe +#if defined(mingw32_HOST_OS)+import System.Win32.Info (getSystemDirectory)+#endif+ import Exception import Foreign (Ptr) -- needed for 2nd stage@@ -309,7 +317,8 @@ linkCmdLineLibs' hsc_env pls = do let dflags@(DynFlags { ldInputs = cmdline_ld_inputs- , libraryPaths = lib_paths}) = hsc_dflags hsc_env+ , libraryPaths = lib_paths_base})+ = hsc_dflags hsc_env -- (c) Link libraries from the command-line let minus_ls_1 = [ lib | Option ('-':'l':lib) <- cmdline_ld_inputs ]@@ -324,8 +333,11 @@ minus_ls = case os of OSMinGW32 -> "pthread" : minus_ls_1 _ -> minus_ls_1+ -- See Note [Fork/Exec Windows]+ gcc_paths <- getGCCPaths dflags os - libspecs <- mapM (locateLib hsc_env False lib_paths) minus_ls+ libspecs+ <- mapM (locateLib hsc_env False lib_paths_base gcc_paths) minus_ls -- (d) Link .o files from the command-line classified_ld_inputs <- mapM (classifyLdInput dflags)@@ -349,9 +361,10 @@ -- on Windows. On Unix OSes this function is a NOP. let all_paths = let paths = takeDirectory (fst $ sPgm_c $ settings dflags) : framework_paths- ++ lib_paths+ ++ lib_paths_base ++ [ takeDirectory dll | DLLPath dll <- libspecs ] in nub $ map normalise paths+ let lib_paths = nub $ lib_paths_base ++ gcc_paths pathCache <- mapM (addLibrarySearchPath hsc_env) all_paths pls1 <- foldM (preloadLib hsc_env lib_paths framework_paths) pls@@ -573,7 +586,7 @@ text "Cannot load" <+> compWay <+> text "objects when GHC is built" <+> ghciWay $$ text "To fix this, either:" $$- text " (1) Use -fexternal-interprter, or" $$+ text " (1) Use -fexternal-interpreter, or" $$ text " (2) Build the program twice: once" <+> ghciWay <> text ", and then" $$ text " with" <+> compWay <+>@@ -721,18 +734,9 @@ adjust_ul _ (DotA fp) = panic ("adjust_ul DotA " ++ show fp) adjust_ul _ (DotDLL fp) = panic ("adjust_ul DotDLL " ++ show fp) adjust_ul _ l@(BCOs {}) = return l-#if !MIN_VERSION_filepath(1,4,1)- stripExtension :: String -> FilePath -> Maybe FilePath- stripExtension [] path = Just path- stripExtension ext@(x:_) path = stripSuffix dotExt path- where dotExt = if isExtSeparator x then ext else '.':ext - stripSuffix :: Eq a => [a] -> [a] -> Maybe [a]- stripSuffix xs ys = fmap reverse $ stripPrefix (reverse xs) (reverse ys)-#endif - {- ********************************************************************** Loading a Decls statement@@ -883,7 +887,8 @@ let platform = targetPlatform dflags let minus_ls = [ lib | Option ('-':'l':lib) <- ldInputs dflags ] let minus_big_ls = [ lib | Option ('-':'L':lib) <- ldInputs dflags ]- (soFile, libPath , libName) <- newTempLibName dflags (soExt platform)+ (soFile, libPath , libName) <-+ newTempLibName dflags TFL_CurrentModule (soExt platform) let dflags2 = dflags { -- We don't want the original ldInputs in@@ -931,7 +936,9 @@ -- Note: We are loading packages with local scope, so to see the -- symbols in this link we must link all loaded packages again. linkDynLib dflags2 objs (pkgs_loaded pls)- consIORef (filesToNotIntermediateClean dflags) soFile++ -- if we got this far, extend the lifetime of the library file+ changeTempFilesLifetime dflags TFL_GhcSession [soFile] m <- loadDLL hsc_env soFile case m of Nothing -> return pls { temp_sos = (libPath, libName) : temp_sos pls }@@ -1087,13 +1094,13 @@ filter (not . null . linkableObjs) bcos_to_unload))) $ purgeLookupSymbolCache hsc_env - let bcos_retained = map linkableModule remaining_bcos_loaded+ let bcos_retained = mkModuleSet $ map linkableModule remaining_bcos_loaded -- Note that we want to remove all *local* -- (i.e. non-isExternal) names too (these are the -- temporary bindings from the command line). keep_name (n,_) = isExternalName n &&- nameModule n `elem` bcos_retained+ nameModule n `elemModuleSet` bcos_retained itbl_env' = filterNameEnv keep_name (itbl_env pls) closure_env' = filterNameEnv keep_name (closure_env pls)@@ -1246,9 +1253,13 @@ then Packages.extraLibraries pkg else Packages.extraGHCiLibraries pkg) ++ [ lib | '-':'l':lib <- Packages.ldOptions pkg ]+ -- See Note [Fork/Exec Windows]+ gcc_paths <- getGCCPaths dflags (platformOS platform) - hs_classifieds <- mapM (locateLib hsc_env True dirs) hs_libs'- extra_classifieds <- mapM (locateLib hsc_env False dirs) extra_libs+ hs_classifieds+ <- mapM (locateLib hsc_env True dirs gcc_paths) hs_libs'+ extra_classifieds+ <- mapM (locateLib hsc_env False dirs gcc_paths) extra_libs let classifieds = hs_classifieds ++ extra_classifieds -- Complication: all the .so's must be loaded before any of the .o's.@@ -1324,8 +1335,9 @@ -- standard system search path. -- For GHCi we tend to prefer dynamic libraries over static ones as -- they are easier to load and manage, have less overhead.-locateLib :: HscEnv -> Bool -> [FilePath] -> String -> IO LibrarySpec-locateLib hsc_env is_hs dirs lib+locateLib :: HscEnv -> Bool -> [FilePath] -> [FilePath] -> String+ -> IO LibrarySpec+locateLib hsc_env is_hs lib_dirs gcc_dirs lib | not is_hs -- For non-Haskell libraries (e.g. gmp, iconv): -- first look in library-dirs for a dynamic library (libfoo.so)@@ -1333,16 +1345,16 @@ -- then look in library-dirs and inplace GCC for a dynamic library (libfoo.so) -- then check for system dynamic libraries (e.g. kernel32.dll on windows) -- then try looking for import libraries on Windows (.dll.a, .lib)- -- then try "gcc --print-file-name" to search gcc's search path -- then look in library-dirs and inplace GCC for a static library (libfoo.a)+ -- then try "gcc --print-file-name" to search gcc's search path -- for a dynamic library (#5289) -- otherwise, assume loadDLL can find it -- = findDll `orElse` findSysDll `orElse` tryImpLib `orElse`- tryGcc `orElse` findArchive `orElse`+ tryGcc `orElse` assumeDll | loading_dynamic_hs_libs -- search for .so libraries first.@@ -1363,6 +1375,7 @@ where dflags = hsc_dflags hsc_env+ dirs = lib_dirs ++ gcc_dirs obj_file = lib <.> "o" dyn_obj_file = lib <.> "dyn_o"@@ -1389,19 +1402,24 @@ findObject = liftM (fmap Object) $ findFile dirs obj_file findDynObject = liftM (fmap Object) $ findFile dirs dyn_obj_file- findArchive = let local name = liftM (fmap Archive) $ findFile dirs name- linked name = liftM (fmap Archive) $ searchForLibUsingGcc dflags name dirs- check name = apply [local name, linked name]- in apply (map check arch_files)+ findArchive = let local name = liftM (fmap Archive) $ findFile dirs name+ in apply (map local arch_files) findHSDll = liftM (fmap DLLPath) $ findFile dirs hs_dyn_lib_file findDll = liftM (fmap DLLPath) $ findFile dirs dyn_lib_file- findSysDll = fmap (fmap $ DLL . dropExtension . takeFileName) $ findSystemLibrary hsc_env so_name- tryGcc = let short = liftM (fmap DLLPath) $ searchForLibUsingGcc dflags so_name dirs- full = liftM (fmap DLLPath) $ searchForLibUsingGcc dflags lib_so_name dirs- in liftM2 (<|>) short full+ findSysDll = fmap (fmap $ DLL . dropExtension . takeFileName) $+ findSystemLibrary hsc_env so_name+ tryGcc = let search = searchForLibUsingGcc dflags+ dllpath = liftM (fmap DLLPath)+ short = dllpath $ search so_name lib_dirs+ full = dllpath $ search lib_so_name lib_dirs+ gcc name = liftM (fmap Archive) $ search name lib_dirs+ files = import_libs ++ arch_files+ in apply $ short : full : map gcc files tryImpLib = case os of- OSMinGW32 -> let check name = liftM (fmap Archive) $ searchForLibUsingGcc dflags name dirs- in apply (map check import_libs)+ OSMinGW32 ->+ let implib name = liftM (fmap Archive) $+ findFile dirs name+ in apply (map implib import_libs) _ -> return Nothing assumeDll = return (DLL lib)@@ -1430,6 +1448,70 @@ if (file == so) then return Nothing else return (Just file)++-- | Retrieve the list of search directory GCC and the System use to find+-- libraries and components. See Note [Fork/Exec Windows].+getGCCPaths :: DynFlags -> OS -> IO [FilePath]+getGCCPaths dflags os+ = case os of+ OSMinGW32 ->+ do gcc_dirs <- getGccSearchDirectory dflags "libraries"+ sys_dirs <- getSystemDirectories+ return $ nub $ gcc_dirs ++ sys_dirs+ _ -> return []++-- | Cache for the GCC search directories as this can't easily change+-- during an invocation of GHC. (Maybe with some env. variable but we'll)+-- deal with that highly unlikely scenario then.+{-# NOINLINE gccSearchDirCache #-}+gccSearchDirCache :: IORef [(String, [String])]+gccSearchDirCache = unsafePerformIO $ newIORef []++-- Note [Fork/Exec Windows]+-- ~~~~~~~~~~~~~~~~~~~~~~~~+-- fork/exec is expensive on Windows, for each time we ask GCC for a library we+-- have to eat the cost of af least 3 of these: gcc -> real_gcc -> cc1.+-- So instead get a list of location that GCC would search and use findDirs+-- which hopefully is written in an optimized mannor to take advantage of+-- caching. At the very least we remove the overhead of the fork/exec and waits+-- which dominate a large percentage of startup time on Windows.+getGccSearchDirectory :: DynFlags -> String -> IO [FilePath]+getGccSearchDirectory dflags key = do+ cache <- readIORef gccSearchDirCache+ case lookup key cache of+ Just x -> return x+ Nothing -> do+ str <- askLd dflags [Option "--print-search-dirs"]+ let line = dropWhile isSpace str+ name = key ++ ": ="+ if null line+ then return []+ else do let val = split $ find name line+ dirs <- filterM doesDirectoryExist val+ modifyIORef' gccSearchDirCache ((key, dirs):)+ return val+ where split :: FilePath -> [FilePath]+ split r = case break (==';') r of+ (s, [] ) -> [s]+ (s, (_:xs)) -> s : split xs++ find :: String -> String -> String+ find r x = let lst = lines x+ val = filter (r `isPrefixOf`) lst+ in if null val+ then []+ else case break (=='=') (head val) of+ (_ , []) -> []+ (_, (_:xs)) -> xs++-- | Get a list of system search directories, this to alleviate pressure on+-- the findSysDll function.+getSystemDirectories :: IO [FilePath]+#if defined(mingw32_HOST_OS)+getSystemDirectories = fmap (:[]) getSystemDirectory+#else+getSystemDirectories = return []+#endif -- ---------------------------------------------------------------------------- -- Loading a dynamic library (dlopen()-ish on Unix, LoadLibrary-ish on Win32)
ghci/RtClosureInspect.hs view
@@ -26,6 +26,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DebuggerUtils import GHCi.RemoteTypes ( HValue ) import qualified GHCi.InfoTable as InfoTable@@ -55,8 +57,10 @@ import DynFlags import Outputable as Ppr import GHC.Arr ( Array(..) )+import GHC.Char import GHC.Exts import GHC.IO ( IO(..) )+import SMRep ( roundUpTo ) import Control.Monad import Data.Maybe@@ -68,6 +72,7 @@ import Foreign import System.IO.Unsafe + --------------------------------------------- -- * A representation of semi evaluated Terms ---------------------------------------------@@ -145,11 +150,13 @@ | Other Int deriving (Show, Eq) +data ClosureNonPtrs = ClosureNonPtrs ByteArray#+ data Closure = Closure { tipe :: ClosureType , infoPtr :: Ptr () , infoTable :: StgInfoTable , ptrs :: Array Int HValue- , nonPtrs :: [Word]+ , nonPtrs :: ClosureNonPtrs } instance Outputable ClosureType where@@ -181,8 +188,7 @@ let tipe = readCType (InfoTable.tipe itbl) elems = fromIntegral (InfoTable.ptrs itbl) ptrsList = Array 0 (elems - 1) elems ptrs- nptrs_data = [W# (indexWordArray# nptrs i)- | I# i <- [0.. fromIntegral (InfoTable.nptrs itbl)-1] ]+ nptrs_data = ClosureNonPtrs nptrs ASSERT(elems >= 0) return () ptrsList `seq` return (Closure tipe iptr0 itbl ptrsList nptrs_data)@@ -338,22 +344,22 @@ return $ cparen (not (null tt) && p >= app_prec) (text dc_tag <+> pprDeeperList fsep tt_docs) -ppr_termM y p Term{dc=Right dc, subTerms=tt} = do+ppr_termM y p Term{dc=Right dc, subTerms=tt} {- | dataConIsInfix dc, (t1:t2:tt') <- tt --TODO fixity = parens (ppr_term1 True t1 <+> ppr dc <+> ppr_term1 True ppr t2) <+> hsep (map (ppr_term1 True) tt) -} -- TODO Printing infix constructors properly- tt_docs' <- mapM (y app_prec) tt- return $ sdocWithPprDebug $ \dbg ->- -- Don't show the dictionary arguments to- -- constructors unless -dppr-debug is on- let tt_docs = if dbg- then tt_docs'- else dropList (dataConTheta dc) tt_docs'- in if null tt_docs- then ppr dc- else cparen (p >= app_prec) $- sep [ppr dc, nest 2 (pprDeeperList fsep tt_docs)]+ = do { tt_docs' <- mapM (y app_prec) tt+ ; return $ ifPprDebug (show_tm tt_docs')+ (show_tm (dropList (dataConTheta dc) tt_docs'))+ -- Don't show the dictionary arguments to+ -- constructors unless -dppr-debug is on+ }+ where+ show_tm tt_docs+ | null tt_docs = ppr dc+ | otherwise = cparen (p >= app_prec) $+ sep [ppr dc, nest 2 (pprDeeperList fsep tt_docs)] ppr_termM y p t@NewtypeWrap{} = pprNewtypeWrap y p t ppr_termM y p RefWrap{wrapped_term=t} = do@@ -371,7 +377,7 @@ ppr_termM1 Prim{value=words, ty=ty} = return $ repPrim (tyConAppTyCon ty) words ppr_termM1 Suspension{ty=ty, bound_to=Nothing} =- return (char '_' <+> ifPprDebug (text "::" <> ppr ty))+ return (char '_' <+> whenPprDebug (text "::" <> ppr ty)) ppr_termM1 Suspension{ty=ty, bound_to=Just n} -- | Just _ <- splitFunTy_maybe ty = return$ ptext (sLit("<function>") | otherwise = return$ parens$ ppr n <> text "::" <> ppr ty@@ -487,7 +493,9 @@ repPrim :: TyCon -> [Word] -> SDoc repPrim t = rep where rep x- | t == charPrimTyCon = text $ show (build x :: Char)+ -- Char# uses native machine words, whereas Char's Storable instance uses+ -- Int32, so we have to read it as an Int.+ | t == charPrimTyCon = text $ show (chr (build x :: Int)) | t == intPrimTyCon = text $ show (build x :: Int) | t == wordPrimTyCon = text $ show (build x :: Word) | t == floatPrimTyCon = text $ show (build x :: Float)@@ -637,7 +645,7 @@ discardResult $ captureConstraints $ do { (ty1, ty2) <- congruenceNewtypes actual expected- ; unifyType noThing ty1 ty2 }+ ; unifyType Nothing ty1 ty2 } -- TOMDO: what about the coercion? -- we should consider family instances @@ -788,48 +796,76 @@ extractSubTerms :: (Type -> HValue -> TcM Term) -> Closure -> [Type] -> TcM [Term]-extractSubTerms recurse clos = liftM thdOf3 . go 0 (nonPtrs clos)+extractSubTerms recurse clos = liftM thdOf3 . go 0 0 where- go ptr_i ws [] = return (ptr_i, ws, [])- go ptr_i ws (ty:tys)+ !(ClosureNonPtrs array) = nonPtrs clos++ go ptr_i arr_i [] = return (ptr_i, arr_i, [])+ go ptr_i arr_i (ty:tys) | Just (tc, elem_tys) <- tcSplitTyConApp_maybe ty , isUnboxedTupleTyCon tc -- See Note [Unboxed tuple RuntimeRep vars] in TyCon- = do (ptr_i, ws, terms0) <- go ptr_i ws (dropRuntimeRepArgs elem_tys)- (ptr_i, ws, terms1) <- go ptr_i ws tys- return (ptr_i, ws, unboxedTupleTerm ty terms0 : terms1)+ = do (ptr_i, arr_i, terms0) <-+ go ptr_i arr_i (dropRuntimeRepArgs elem_tys)+ (ptr_i, arr_i, terms1) <- go ptr_i arr_i tys+ return (ptr_i, arr_i, unboxedTupleTerm ty terms0 : terms1) | otherwise = case typePrimRepArgs ty of [rep_ty] -> do- (ptr_i, ws, term0) <- go_rep ptr_i ws ty rep_ty- (ptr_i, ws, terms1) <- go ptr_i ws tys- return (ptr_i, ws, term0 : terms1)+ (ptr_i, arr_i, term0) <- go_rep ptr_i arr_i ty rep_ty+ (ptr_i, arr_i, terms1) <- go ptr_i arr_i tys+ return (ptr_i, arr_i, term0 : terms1) rep_tys -> do- (ptr_i, ws, terms0) <- go_unary_types ptr_i ws rep_tys- (ptr_i, ws, terms1) <- go ptr_i ws tys- return (ptr_i, ws, unboxedTupleTerm ty terms0 : terms1)+ (ptr_i, arr_i, terms0) <- go_unary_types ptr_i arr_i rep_tys+ (ptr_i, arr_i, terms1) <- go ptr_i arr_i tys+ return (ptr_i, arr_i, unboxedTupleTerm ty terms0 : terms1) - go_unary_types ptr_i ws [] = return (ptr_i, ws, [])- go_unary_types ptr_i ws (rep_ty:rep_tys) = do+ go_unary_types ptr_i arr_i [] = return (ptr_i, arr_i, [])+ go_unary_types ptr_i arr_i (rep_ty:rep_tys) = do tv <- newVar liftedTypeKind- (ptr_i, ws, term0) <- go_rep ptr_i ws tv rep_ty- (ptr_i, ws, terms1) <- go_unary_types ptr_i ws rep_tys- return (ptr_i, ws, term0 : terms1)+ (ptr_i, arr_i, term0) <- go_rep ptr_i arr_i tv rep_ty+ (ptr_i, arr_i, terms1) <- go_unary_types ptr_i arr_i rep_tys+ return (ptr_i, arr_i, term0 : terms1) - go_rep ptr_i ws ty rep- | isGcPtrRep rep- = do t <- appArr (recurse ty) (ptrs clos) ptr_i- return (ptr_i + 1, ws, t)- | otherwise- = do dflags <- getDynFlags- let (ws0, ws1) = splitAt (primRepSizeW dflags rep) ws- return (ptr_i, ws1, Prim ty ws0)+ go_rep ptr_i arr_i ty rep+ | isGcPtrRep rep = do+ t <- appArr (recurse ty) (ptrs clos) ptr_i+ return (ptr_i + 1, arr_i, t)+ | otherwise = do+ -- This is a bit involved since we allow packing multiple fields+ -- within a single word. See also+ -- StgCmmLayout.mkVirtHeapOffsetsWithPadding+ dflags <- getDynFlags+ let word_size = wORD_SIZE dflags+ size_b = primRepSizeB dflags rep+ -- Fields are always aligned.+ !aligned_idx = roundUpTo arr_i size_b+ !new_arr_i = aligned_idx + size_b+ ws+ | size_b < word_size = [index size_b array aligned_idx]+ | otherwise =+ let (q, r) = size_b `quotRem` word_size+ in ASSERT( r == 0 )+ [ W# (indexWordArray# array i)+ | o <- [0.. q - 1]+ , let !(I# i) = (aligned_idx + o) `quot` word_size+ ]+ return (ptr_i, new_arr_i, Prim ty ws) unboxedTupleTerm ty terms = Term ty (Right (tupleDataCon Unboxed (length terms))) (error "unboxedTupleTerm: no HValue for unboxed tuple") terms + index item_size_b array (I# index_b) =+ case item_size_b of+ -- indexWord*Array# functions take offsets dependent not in bytes,+ -- but in multiples of an element's size.+ 1 -> W# (indexWord8Array# array index_b)+ 2 -> W# (indexWord16Array# array (index_b `quotInt#` 2#))+ 4 -> W# (indexWord32Array# array (index_b `quotInt#` 4#))+ _ -> panic ("Weird byte-index: " ++ show (I# index_b)) + -- Fast, breadth-first Type reconstruction ------------------------------------------ cvReconstructType :: HscEnv -> Int -> GhciType -> HValue -> IO (Maybe Type)@@ -1186,7 +1222,7 @@ (_, vars) <- instTyVars (tyConTyVars new_tycon) let ty' = mkTyConApp new_tycon (mkTyVarTys vars) rep_ty = unwrapType ty'- _ <- liftTcM (unifyType noThing ty rep_ty)+ _ <- liftTcM (unifyType Nothing ty rep_ty) -- assumes that reptype doesn't ^^^^ touch tyconApp args return ty'
hsSyn/Convert.hs view
@@ -6,12 +6,15 @@ This module converts Template Haskell syntax into HsSyn -} +{-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE ScopedTypeVariables #-} module Convert( convertToHsExpr, convertToPat, convertToHsDecls, convertToHsType, thRdrNameGuesses ) where +import GhcPrelude+ import HsSyn as Hs import qualified Class import RdrName@@ -46,20 +49,20 @@ ------------------------------------------------------------------- -- The external interface -convertToHsDecls :: SrcSpan -> [TH.Dec] -> Either MsgDoc [LHsDecl RdrName]+convertToHsDecls :: SrcSpan -> [TH.Dec] -> Either MsgDoc [LHsDecl GhcPs] convertToHsDecls loc ds = initCvt loc (fmap catMaybes (mapM cvt_dec ds)) where cvt_dec d = wrapMsg "declaration" d (cvtDec d) -convertToHsExpr :: SrcSpan -> TH.Exp -> Either MsgDoc (LHsExpr RdrName)+convertToHsExpr :: SrcSpan -> TH.Exp -> Either MsgDoc (LHsExpr GhcPs) convertToHsExpr loc e = initCvt loc $ wrapMsg "expression" e $ cvtl e -convertToPat :: SrcSpan -> TH.Pat -> Either MsgDoc (LPat RdrName)+convertToPat :: SrcSpan -> TH.Pat -> Either MsgDoc (LPat GhcPs) convertToPat loc p = initCvt loc $ wrapMsg "pattern" p $ cvtPat p -convertToHsType :: SrcSpan -> TH.Type -> Either MsgDoc (LHsType RdrName)+convertToHsType :: SrcSpan -> TH.Type -> Either MsgDoc (LHsType GhcPs) convertToHsType loc t = initCvt loc $ wrapMsg "type" t $ cvtType t @@ -133,10 +136,10 @@ Right (loc',v) -> Right (loc',L loc v)) --------------------------------------------------------------------cvtDecs :: [TH.Dec] -> CvtM [LHsDecl RdrName]+cvtDecs :: [TH.Dec] -> CvtM [LHsDecl GhcPs] cvtDecs = fmap catMaybes . mapM cvtDec -cvtDec :: TH.Dec -> CvtM (Maybe (LHsDecl RdrName))+cvtDec :: TH.Dec -> CvtM (Maybe (LHsDecl GhcPs)) cvtDec (TH.ValD pat body ds) | TH.VarP s <- pat = do { s' <- vNameL s@@ -248,7 +251,7 @@ -- no docs in TH ^^ } where- cvt_at_def :: LTyFamInstDecl RdrName -> CvtM (LTyFamDefltEqn RdrName)+ cvt_at_def :: LTyFamInstDecl GhcPs -> CvtM (LTyFamDefltEqn GhcPs) -- Very similar to what happens in RdrHsSyn.mkClassDecl cvt_at_def decl = case RdrHsSyn.mkATDefault decl of Right def -> return def@@ -299,10 +302,10 @@ , dd_cons = cons', dd_derivs = derivs' } ; returnJustL $ InstD $ DataFamInstD- { dfid_inst = DataFamInstDecl { dfid_tycon = tc', dfid_pats = typats'- , dfid_defn = defn- , dfid_fixity = Prefix- , dfid_fvs = placeHolderNames } }}+ { dfid_inst = DataFamInstDecl { dfid_eqn = mkHsImplicitBndrs $+ FamEqn { feqn_tycon = tc', feqn_pats = typats'+ , feqn_rhs = defn+ , feqn_fixity = Prefix } }}} cvtDec (NewtypeInstD ctxt tc tys ksig constr derivs) = do { (ctxt', tc', typats') <- cvt_tyinst_hdr ctxt tc tys@@ -314,17 +317,16 @@ , dd_kindSig = ksig' , dd_cons = [con'], dd_derivs = derivs' } ; returnJustL $ InstD $ DataFamInstD- { dfid_inst = DataFamInstDecl { dfid_tycon = tc', dfid_pats = typats'- , dfid_defn = defn- , dfid_fixity = Prefix- , dfid_fvs = placeHolderNames } }}+ { dfid_inst = DataFamInstDecl { dfid_eqn = mkHsImplicitBndrs $+ FamEqn { feqn_tycon = tc', feqn_pats = typats'+ , feqn_rhs = defn+ , feqn_fixity = Prefix } }}} cvtDec (TySynInstD tc eqn) = do { tc' <- tconNameL tc- ; eqn' <- cvtTySynEqn tc' eqn+ ; L _ eqn' <- cvtTySynEqn tc' eqn ; returnJustL $ InstD $ TyFamInstD- { tfid_inst = TyFamInstDecl { tfid_eqn = eqn'- , tfid_fvs = placeHolderNames } } }+ { tfid_inst = TyFamInstDecl { tfid_eqn = eqn' } } } cvtDec (OpenTypeFamilyD head) = do { (tc', tyvars', result', injectivity') <- cvt_tyfam_head head@@ -365,12 +367,12 @@ ; returnJustL $ Hs.ValD $ PatSynBind $ PSB nm' placeHolderType args' pat' dir' } where- cvtArgs (TH.PrefixPatSyn args) = Hs.PrefixPatSyn <$> mapM vNameL args- cvtArgs (TH.InfixPatSyn a1 a2) = Hs.InfixPatSyn <$> vNameL a1 <*> vNameL a2+ cvtArgs (TH.PrefixPatSyn args) = Hs.PrefixCon <$> mapM vNameL args+ cvtArgs (TH.InfixPatSyn a1 a2) = Hs.InfixCon <$> vNameL a1 <*> vNameL a2 cvtArgs (TH.RecordPatSyn sels) = do { sels' <- mapM vNameL sels ; vars' <- mapM (vNameL . mkNameS . nameBase) sels- ; return $ Hs.RecordPatSyn $ zipWith RecordPatSynField sels' vars' }+ ; return $ Hs.RecCon $ zipWith RecordPatSynField sels' vars' } cvtDir _ Unidir = return Unidirectional cvtDir _ ImplBidir = return ImplicitBidirectional@@ -384,22 +386,23 @@ ; returnJustL $ Hs.SigD $ PatSynSig [nm'] (mkLHsSigType ty') } -----------------cvtTySynEqn :: Located RdrName -> TySynEqn -> CvtM (LTyFamInstEqn RdrName)+cvtTySynEqn :: Located RdrName -> TySynEqn -> CvtM (LTyFamInstEqn GhcPs) cvtTySynEqn tc (TySynEqn lhs rhs) = do { lhs' <- mapM (wrap_apps <=< cvtType) lhs ; rhs' <- cvtType rhs- ; returnL $ TyFamEqn { tfe_tycon = tc- , tfe_pats = mkHsImplicitBndrs lhs'- , tfe_fixity = Prefix- , tfe_rhs = rhs' } }+ ; returnL $ mkHsImplicitBndrs+ $ FamEqn { feqn_tycon = tc+ , feqn_pats = lhs'+ , feqn_fixity = Prefix+ , feqn_rhs = rhs' } } ---------------- cvt_ci_decs :: MsgDoc -> [TH.Dec]- -> CvtM (LHsBinds RdrName,- [LSig RdrName],- [LFamilyDecl RdrName],- [LTyFamInstDecl RdrName],- [LDataFamInstDecl RdrName])+ -> CvtM (LHsBinds GhcPs,+ [LSig GhcPs],+ [LFamilyDecl GhcPs],+ [LTyFamInstDecl GhcPs],+ [LDataFamInstDecl GhcPs]) -- Convert the declarations inside a class or instance decl -- ie signatures, bindings, and associated types cvt_ci_decs doc decs@@ -416,9 +419,9 @@ ---------------- cvt_tycl_hdr :: TH.Cxt -> TH.Name -> [TH.TyVarBndr]- -> CvtM ( LHsContext RdrName+ -> CvtM ( LHsContext GhcPs , Located RdrName- , LHsQTyVars RdrName)+ , LHsQTyVars GhcPs) cvt_tycl_hdr cxt tc tvs = do { cxt' <- cvtContext cxt ; tc' <- tconNameL tc@@ -427,21 +430,21 @@ } cvt_tyinst_hdr :: TH.Cxt -> TH.Name -> [TH.Type]- -> CvtM ( LHsContext RdrName+ -> CvtM ( LHsContext GhcPs , Located RdrName- , HsImplicitBndrs RdrName [LHsType RdrName])+ , HsTyPats GhcPs) cvt_tyinst_hdr cxt tc tys = do { cxt' <- cvtContext cxt ; tc' <- tconNameL tc ; tys' <- mapM (wrap_apps <=< cvtType) tys- ; return (cxt', tc', mkHsImplicitBndrs tys') }+ ; return (cxt', tc', tys') } ---------------- cvt_tyfam_head :: TypeFamilyHead -> CvtM ( Located RdrName- , LHsQTyVars RdrName- , Hs.LFamilyResultSig RdrName- , Maybe (Hs.LInjectivityAnn RdrName))+ , LHsQTyVars GhcPs+ , Hs.LFamilyResultSig GhcPs+ , Maybe (Hs.LInjectivityAnn GhcPs)) cvt_tyfam_head (TypeFamilyHead tc tyvars result injectivity) = do {(_, tc', tyvars') <- cvt_tycl_hdr [] tc tyvars@@ -453,23 +456,24 @@ -- Partitioning declarations ------------------------------------------------------------------- -is_fam_decl :: LHsDecl RdrName -> Either (LFamilyDecl RdrName) (LHsDecl RdrName)+is_fam_decl :: LHsDecl GhcPs -> Either (LFamilyDecl GhcPs) (LHsDecl GhcPs) is_fam_decl (L loc (TyClD (FamDecl { tcdFam = d }))) = Left (L loc d) is_fam_decl decl = Right decl -is_tyfam_inst :: LHsDecl RdrName -> Either (LTyFamInstDecl RdrName) (LHsDecl RdrName)+is_tyfam_inst :: LHsDecl GhcPs -> Either (LTyFamInstDecl GhcPs) (LHsDecl GhcPs) is_tyfam_inst (L loc (Hs.InstD (TyFamInstD { tfid_inst = d }))) = Left (L loc d) is_tyfam_inst decl = Right decl -is_datafam_inst :: LHsDecl RdrName -> Either (LDataFamInstDecl RdrName) (LHsDecl RdrName)+is_datafam_inst :: LHsDecl GhcPs+ -> Either (LDataFamInstDecl GhcPs) (LHsDecl GhcPs) is_datafam_inst (L loc (Hs.InstD (DataFamInstD { dfid_inst = d }))) = Left (L loc d) is_datafam_inst decl = Right decl -is_sig :: LHsDecl RdrName -> Either (LSig RdrName) (LHsDecl RdrName)+is_sig :: LHsDecl GhcPs -> Either (LSig GhcPs) (LHsDecl GhcPs) is_sig (L loc (Hs.SigD sig)) = Left (L loc sig) is_sig decl = Right decl -is_bind :: LHsDecl RdrName -> Either (LHsBind RdrName) (LHsDecl RdrName)+is_bind :: LHsDecl GhcPs -> Either (LHsBind GhcPs) (LHsDecl GhcPs) is_bind (L loc (Hs.ValD bind)) = Left (L loc bind) is_bind decl = Right decl @@ -482,7 +486,7 @@ -- Data types --------------------------------------------------- -cvtConstr :: TH.Con -> CvtM (LConDecl RdrName)+cvtConstr :: TH.Con -> CvtM (LConDecl GhcPs) cvtConstr (NormalC c strtys) = do { c' <- cNameL c@@ -550,7 +554,7 @@ cvtSrcStrictness SourceLazy = SrcLazy cvtSrcStrictness SourceStrict = SrcStrict -cvt_arg :: (TH.Bang, TH.Type) -> CvtM (LHsType RdrName)+cvt_arg :: (TH.Bang, TH.Type) -> CvtM (LHsType GhcPs) cvt_arg (Bang su ss, ty) = do { ty'' <- cvtType ty ; ty' <- wrap_apps ty''@@ -558,7 +562,7 @@ ; let ss' = cvtSrcStrictness ss ; returnL $ HsBangTy (HsSrcBang NoSourceText su' ss') ty' } -cvt_id_arg :: (TH.Name, TH.Bang, TH.Type) -> CvtM (LConDeclField RdrName)+cvt_id_arg :: (TH.Name, TH.Bang, TH.Type) -> CvtM (LConDeclField GhcPs) cvt_id_arg (i, str, ty) = do { L li i' <- vNameL i ; ty' <- cvt_arg (str,ty)@@ -568,7 +572,7 @@ , cd_fld_type = ty' , cd_fld_doc = Nothing}) } -cvtDerivs :: [TH.DerivClause] -> CvtM (HsDeriving RdrName)+cvtDerivs :: [TH.DerivClause] -> CvtM (HsDeriving GhcPs) cvtDerivs cs = do { cs' <- mapM cvtDerivClause cs ; returnL cs' } @@ -582,7 +586,7 @@ -- Foreign declarations ------------------------------------------ -cvtForD :: Foreign -> CvtM (ForeignDecl RdrName)+cvtForD :: Foreign -> CvtM (ForeignDecl GhcPs) cvtForD (ImportF callconv safety from nm ty) -- the prim and javascript calling conventions do not support headers -- and are inserted verbatim, analogous to mkImport in RdrHsSyn@@ -635,7 +639,7 @@ -- Pragmas ------------------------------------------ -cvtPragmaD :: Pragma -> CvtM (Maybe (LHsDecl RdrName))+cvtPragmaD :: Pragma -> CvtM (Maybe (LHsDecl GhcPs)) cvtPragmaD (InlineP nm inline rm phases) = do { nm' <- vNameL nm ; let dflt = dfltActivation inline@@ -658,7 +662,7 @@ ; let (inline', dflt,srcText) = case inline of Just inline1 -> (cvtInline inline1, dfltActivation inline1, src inline1)- Nothing -> (EmptyInlineSpec, AlwaysActive,+ Nothing -> (NoUserInline, AlwaysActive, "{-# SPECIALISE") ; let ip = InlinePragma { inl_src = SourceText srcText , inl_inline = inline'@@ -727,7 +731,7 @@ cvtPhases (FromPhase i) _ = ActiveAfter NoSourceText i cvtPhases (BeforePhase i) _ = ActiveBefore NoSourceText i -cvtRuleBndr :: TH.RuleBndr -> CvtM (Hs.LRuleBndr RdrName)+cvtRuleBndr :: TH.RuleBndr -> CvtM (Hs.LRuleBndr GhcPs) cvtRuleBndr (RuleVar n) = do { n' <- vNameL n ; return $ noLoc $ Hs.RuleBndr n' }@@ -740,7 +744,7 @@ -- Declarations --------------------------------------------------- -cvtLocalDecs :: MsgDoc -> [TH.Dec] -> CvtM (HsLocalBinds RdrName)+cvtLocalDecs :: MsgDoc -> [TH.Dec] -> CvtM (HsLocalBinds GhcPs) cvtLocalDecs doc ds | null ds = return EmptyLocalBinds@@ -752,28 +756,36 @@ ; return (HsValBinds (ValBindsIn (listToBag binds) sigs)) } cvtClause :: HsMatchContext RdrName- -> TH.Clause -> CvtM (Hs.LMatch RdrName (LHsExpr RdrName))+ -> TH.Clause -> CvtM (Hs.LMatch GhcPs (LHsExpr GhcPs)) cvtClause ctxt (Clause ps body wheres) = do { ps' <- cvtPats ps ; pps <- mapM wrap_conpat ps' ; g' <- cvtGuard body ; ds' <- cvtLocalDecs (text "a where clause") wheres- ; returnL $ Hs.Match ctxt pps Nothing- (GRHSs g' (noLoc ds')) }+ ; returnL $ Hs.Match ctxt pps (GRHSs g' (noLoc ds')) } ------------------------------------------------------------------- -- Expressions ------------------------------------------------------------------- -cvtl :: TH.Exp -> CvtM (LHsExpr RdrName)+cvtl :: TH.Exp -> CvtM (LHsExpr GhcPs) cvtl e = wrapL (cvt e) where cvt (VarE s) = do { s' <- vName s; return $ HsVar (noLoc s') } cvt (ConE s) = do { s' <- cName s; return $ HsVar (noLoc s') } cvt (LitE l)- | overloadedLit l = do { l' <- cvtOverLit l; return $ HsOverLit l' }- | otherwise = do { l' <- cvtLit l; return $ HsLit l' }+ | overloadedLit l = go cvtOverLit HsOverLit isCompoundHsOverLit+ | otherwise = go cvtLit HsLit isCompoundHsLit+ where+ go :: (Lit -> CvtM (l GhcPs))+ -> (l GhcPs -> HsExpr GhcPs)+ -> (l GhcPs -> Bool)+ -> CvtM (HsExpr GhcPs)+ go cvt_lit mk_expr is_compound_lit = do+ l' <- cvt_lit l+ let e' = mk_expr l'+ return $ if is_compound_lit l' then HsPar (noLoc e') else e' cvt (AppE x@(LamE _ _) y) = do { x' <- cvtl x; y' <- cvtl y ; return $ HsApp (mkLHsPar x') (mkLHsPar y')} cvt (AppE x y) = do { x' <- cvtl x; y' <- cvtl y@@ -782,9 +794,15 @@ ; t' <- cvtType t ; tp <- wrap_apps t' ; return $ HsAppType e' $ mkHsWildCardBndrs tp }+ cvt (LamE [] e) = cvt e -- Degenerate case. We convert the body as its+ -- own expression to avoid pretty-printing+ -- oddities that can result from zero-argument+ -- lambda expressions. See #13856. cvt (LamE ps e) = do { ps' <- cvtPats ps; e' <- cvtl e+ ; let pats = map parenthesizeCompoundPat ps' ; return $ HsLam (mkMatchGroup FromSource- [mkSimpleMatch LambdaExpr ps' e'])}+ [mkSimpleMatch LambdaExpr+ pats e'])} cvt (LamCaseE ms) = do { ms' <- mapM (cvtMatch LambdaExpr) ms ; return $ HsLamCase (mkMatchGroup FromSource ms') }@@ -858,6 +876,7 @@ ; return $ mkRdrRecordUpd e' flds' } cvt (StaticE e) = fmap (HsStatic placeHolderNames) $ cvtl e cvt (UnboundVarE s) = do { s' <- vName s; return $ HsVar (noLoc s') }+ cvt (LabelE s) = do { return $ HsOverLabel Nothing (fsLit s) } {- Note [Dropping constructors] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -875,14 +894,15 @@ which we don't want. -} -cvtFld :: (RdrName -> t) -> (TH.Name, TH.Exp) -> CvtM (LHsRecField' t (LHsExpr RdrName))+cvtFld :: (RdrName -> t) -> (TH.Name, TH.Exp)+ -> CvtM (LHsRecField' t (LHsExpr GhcPs)) cvtFld f (v,e) = do { v' <- vNameL v; e' <- cvtl e ; return (noLoc $ HsRecField { hsRecFieldLbl = fmap f v' , hsRecFieldArg = e' , hsRecPun = False}) } -cvtDD :: Range -> CvtM (ArithSeqInfo RdrName)+cvtDD :: Range -> CvtM (ArithSeqInfo GhcPs) cvtDD (FromR x) = do { x' <- cvtl x; return $ From x' } cvtDD (FromThenR x y) = do { x' <- cvtl x; y' <- cvtl y; return $ FromThen x' y' } cvtDD (FromToR x y) = do { x' <- cvtl x; y' <- cvtl y; return $ FromTo x' y' }@@ -940,7 +960,7 @@ When we call @cvtOpApp@ from @cvtl@, the first argument will always be left-biased since we have already run @cvtl@ on it. -}-cvtOpApp :: LHsExpr RdrName -> TH.Exp -> TH.Exp -> CvtM (HsExpr RdrName)+cvtOpApp :: LHsExpr GhcPs -> TH.Exp -> TH.Exp -> CvtM (HsExpr GhcPs) cvtOpApp x op1 (UInfixE y op2 z) = do { l <- wrapL $ cvtOpApp x op1 y ; cvtOpApp l op2 z }@@ -953,7 +973,7 @@ -- Do notation and statements ------------------------------------- -cvtHsDo :: HsStmtContext Name.Name -> [TH.Stmt] -> CvtM (HsExpr RdrName)+cvtHsDo :: HsStmtContext Name.Name -> [TH.Stmt] -> CvtM (HsExpr GhcPs) cvtHsDo do_or_lc stmts | null stmts = failWith (text "Empty stmt list in do-block") | otherwise@@ -970,10 +990,10 @@ , nest 2 $ Outputable.ppr stmt , text "(It should be an expression.)" ] -cvtStmts :: [TH.Stmt] -> CvtM [Hs.LStmt RdrName (LHsExpr RdrName)]+cvtStmts :: [TH.Stmt] -> CvtM [Hs.LStmt GhcPs (LHsExpr GhcPs)] cvtStmts = mapM cvtStmt -cvtStmt :: TH.Stmt -> CvtM (Hs.LStmt RdrName (LHsExpr RdrName))+cvtStmt :: TH.Stmt -> CvtM (Hs.LStmt GhcPs (LHsExpr GhcPs)) cvtStmt (NoBindS e) = do { e' <- cvtl e; returnL $ mkBodyStmt e' } cvtStmt (TH.BindS p e) = do { p' <- cvtPat p; e' <- cvtl e; returnL $ mkBindStmt p' e' } cvtStmt (TH.LetS ds) = do { ds' <- cvtLocalDecs (text "a let binding") ds@@ -983,7 +1003,7 @@ cvt_one ds = do { ds' <- cvtStmts ds; return (ParStmtBlock ds' undefined noSyntaxExpr) } cvtMatch :: HsMatchContext RdrName- -> TH.Match -> CvtM (Hs.LMatch RdrName (LHsExpr RdrName))+ -> TH.Match -> CvtM (Hs.LMatch GhcPs (LHsExpr GhcPs)) cvtMatch ctxt (TH.Match p body decs) = do { p' <- cvtPat p ; lp <- case ctxt of@@ -991,25 +1011,24 @@ _ -> wrap_conpat p' ; g' <- cvtGuard body ; decs' <- cvtLocalDecs (text "a where clause") decs- ; returnL $ Hs.Match ctxt [lp] Nothing- (GRHSs g' (noLoc decs')) }+ ; returnL $ Hs.Match ctxt [lp] (GRHSs g' (noLoc decs')) } -cvtGuard :: TH.Body -> CvtM [LGRHS RdrName (LHsExpr RdrName)]+cvtGuard :: TH.Body -> CvtM [LGRHS GhcPs (LHsExpr GhcPs)] cvtGuard (GuardedB pairs) = mapM cvtpair pairs cvtGuard (NormalB e) = do { e' <- cvtl e; g' <- returnL $ GRHS [] e'; return [g'] } -cvtpair :: (TH.Guard, TH.Exp) -> CvtM (LGRHS RdrName (LHsExpr RdrName))+cvtpair :: (TH.Guard, TH.Exp) -> CvtM (LGRHS GhcPs (LHsExpr GhcPs)) cvtpair (NormalG ge,rhs) = do { ge' <- cvtl ge; rhs' <- cvtl rhs ; g' <- returnL $ mkBodyStmt ge' ; returnL $ GRHS [g'] rhs' } cvtpair (PatG gs,rhs) = do { gs' <- cvtStmts gs; rhs' <- cvtl rhs ; returnL $ GRHS gs' rhs' } -cvtOverLit :: Lit -> CvtM (HsOverLit RdrName)+cvtOverLit :: Lit -> CvtM (HsOverLit GhcPs) cvtOverLit (IntegerL i)- = do { force i; return $ mkHsIntegral NoSourceText i placeHolderType}+ = do { force i; return $ mkHsIntegral (mkIntegralLit i) placeHolderType} cvtOverLit (RationalL r)- = do { force r; return $ mkHsFractional (cvtFractionalLit r) placeHolderType}+ = do { force r; return $ mkHsFractional (mkFractionalLit r) placeHolderType} cvtOverLit (StringL s) = do { let { s' = mkFastString s } ; force s'@@ -1040,11 +1059,13 @@ go cs (LitE (CharL c) : ys) = go (c:cs) ys go _ _ = Nothing -cvtLit :: Lit -> CvtM HsLit+cvtLit :: Lit -> CvtM (HsLit GhcPs) cvtLit (IntPrimL i) = do { force i; return $ HsIntPrim NoSourceText i } cvtLit (WordPrimL w) = do { force w; return $ HsWordPrim NoSourceText w }-cvtLit (FloatPrimL f) = do { force f; return $ HsFloatPrim (cvtFractionalLit f) }-cvtLit (DoublePrimL f) = do { force f; return $ HsDoublePrim (cvtFractionalLit f) }+cvtLit (FloatPrimL f)+ = do { force f; return $ HsFloatPrim def (mkFractionalLit f) }+cvtLit (DoublePrimL f)+ = do { force f; return $ HsDoublePrim def (mkFractionalLit f) } cvtLit (CharL c) = do { force c; return $ HsChar NoSourceText c } cvtLit (CharPrimL c) = do { force c; return $ HsCharPrim NoSourceText c } cvtLit (StringL s) = do { let { s' = mkFastString s }@@ -1061,13 +1082,13 @@ quotedSourceText :: String -> SourceText quotedSourceText s = SourceText $ "\"" ++ s ++ "\"" -cvtPats :: [TH.Pat] -> CvtM [Hs.LPat RdrName]+cvtPats :: [TH.Pat] -> CvtM [Hs.LPat GhcPs] cvtPats pats = mapM cvtPat pats -cvtPat :: TH.Pat -> CvtM (Hs.LPat RdrName)+cvtPat :: TH.Pat -> CvtM (Hs.LPat GhcPs) cvtPat pat = wrapL (cvtp pat) -cvtp :: TH.Pat -> CvtM (Hs.Pat RdrName)+cvtp :: TH.Pat -> CvtM (Hs.Pat GhcPs) cvtp (TH.LitP l) | overloadedLit l = do { l' <- cvtOverLit l ; return (mkNPat (noLoc l') Nothing) }@@ -1108,7 +1129,7 @@ cvtp (ViewP e p) = do { e' <- cvtl e; p' <- cvtPat p ; return $ ViewPat e' p' placeHolderType } -cvtPatFld :: (TH.Name, TH.Pat) -> CvtM (LHsRecField RdrName (LPat RdrName))+cvtPatFld :: (TH.Name, TH.Pat) -> CvtM (LHsRecField GhcPs (LPat GhcPs)) cvtPatFld (s,p) = do { L ls s' <- vNameL s; p' <- cvtPat p ; return (noLoc $ HsRecField { hsRecFieldLbl@@ -1116,7 +1137,7 @@ , hsRecFieldArg = p' , hsRecPun = False}) } -wrap_conpat :: Hs.LPat RdrName -> CvtM (Hs.LPat RdrName)+wrap_conpat :: Hs.LPat GhcPs -> CvtM (Hs.LPat GhcPs) wrap_conpat p@(L _ (ConPatIn _ (InfixCon{}))) = returnL $ ParPat p wrap_conpat p@(L _ (ConPatIn _ (PrefixCon []))) = return p wrap_conpat p@(L _ (ConPatIn _ (PrefixCon _))) = returnL $ ParPat p@@ -1127,7 +1148,7 @@ See the @cvtOpApp@ documentation for how this function works. -}-cvtOpAppP :: Hs.LPat RdrName -> TH.Name -> TH.Pat -> CvtM (Hs.Pat RdrName)+cvtOpAppP :: Hs.LPat GhcPs -> TH.Name -> TH.Pat -> CvtM (Hs.Pat GhcPs) cvtOpAppP x op1 (UInfixP y op2 z) = do { l <- wrapL $ cvtOpAppP x op1 y ; cvtOpAppP l op2 z }@@ -1139,10 +1160,10 @@ ----------------------------------------------------------- -- Types and type variables -cvtTvs :: [TH.TyVarBndr] -> CvtM (LHsQTyVars RdrName)+cvtTvs :: [TH.TyVarBndr] -> CvtM (LHsQTyVars GhcPs) cvtTvs tvs = do { tvs' <- mapM cvt_tv tvs; return (mkHsQTvs tvs') } -cvt_tv :: TH.TyVarBndr -> CvtM (LHsTyVarBndr RdrName)+cvt_tv :: TH.TyVarBndr -> CvtM (LHsTyVarBndr GhcPs) cvt_tv (TH.PlainTV nm) = do { nm' <- tNameL nm ; returnL $ UserTyVar nm' }@@ -1157,14 +1178,14 @@ cvtRole TH.PhantomR = Just Coercion.Phantom cvtRole TH.InferR = Nothing -cvtContext :: TH.Cxt -> CvtM (LHsContext RdrName)+cvtContext :: TH.Cxt -> CvtM (LHsContext GhcPs) cvtContext tys = do { preds' <- mapM cvtPred tys; returnL preds' } -cvtPred :: TH.Pred -> CvtM (LHsType RdrName)+cvtPred :: TH.Pred -> CvtM (LHsType GhcPs) cvtPred = cvtType cvtDerivClause :: TH.DerivClause- -> CvtM (LHsDerivingClause RdrName)+ -> CvtM (LHsDerivingClause GhcPs) cvtDerivClause (TH.DerivClause ds ctxt) = do { ctxt'@(L loc _) <- fmap (map mkLHsSigType) <$> cvtContext ctxt ; let ds' = fmap (L loc . cvtDerivStrategy) ds@@ -1175,15 +1196,15 @@ cvtDerivStrategy TH.AnyclassStrategy = Hs.AnyclassStrategy cvtDerivStrategy TH.NewtypeStrategy = Hs.NewtypeStrategy -cvtType :: TH.Type -> CvtM (LHsType RdrName)+cvtType :: TH.Type -> CvtM (LHsType GhcPs) cvtType = cvtTypeKind "type" -cvtTypeKind :: String -> TH.Type -> CvtM (LHsType RdrName)+cvtTypeKind :: String -> TH.Type -> CvtM (LHsType GhcPs) cvtTypeKind ty_str ty = do { (head_ty, tys') <- split_ty_app ty ; case head_ty of TupleT n- | length tys' == n -- Saturated+ | tys' `lengthIs` n -- Saturated -> if n==1 then return (head tys') -- Singleton tuples treated -- like nothing (ie just parens) else returnL (HsTupleTy HsBoxedOrConstraintTuple tys')@@ -1193,7 +1214,7 @@ -> mk_apps (HsTyVar NotPromoted (noLoc (getRdrName (tupleTyCon Boxed n)))) tys' UnboxedTupleT n- | length tys' == n -- Saturated+ | tys' `lengthIs` n -- Saturated -> returnL (HsTupleTy HsUnboxedTuple tys') | otherwise -> mk_apps (HsTyVar NotPromoted@@ -1204,13 +1225,18 @@ vcat [ text "Illegal sum arity:" <+> text (show n) , nest 2 $ text "Sums must have an arity of at least 2" ]- | length tys' == n -- Saturated+ | tys' `lengthIs` n -- Saturated -> returnL (HsSumTy tys') | otherwise -> mk_apps (HsTyVar NotPromoted (noLoc (getRdrName (sumTyCon n)))) tys' ArrowT- | [x',y'] <- tys' -> returnL (HsFunTy x' y')+ | [x',y'] <- tys' -> do+ x'' <- case x' of+ L _ HsFunTy{} -> returnL (HsParTy x')+ L _ HsForAllTy{} -> returnL (HsParTy x') -- #14646+ _ -> return x'+ returnL (HsFunTy x'' y') | otherwise -> mk_apps (HsTyVar NotPromoted (noLoc (getRdrName funTyCon))) tys'@@ -1309,28 +1335,53 @@ } -- | Constructs an application of a type to arguments passed in a list.-mk_apps :: HsType RdrName -> [LHsType RdrName] -> CvtM (LHsType RdrName)+mk_apps :: HsType GhcPs -> [LHsType GhcPs] -> CvtM (LHsType GhcPs) mk_apps head_ty [] = returnL head_ty mk_apps head_ty (ty:tys) = do { head_ty' <- returnL head_ty ; p_ty <- add_parens ty ; mk_apps (HsAppTy head_ty' p_ty) tys } where- add_parens t@(L _ HsAppTy{}) = returnL (HsParTy t)- add_parens t = return t+ -- See Note [Adding parens for splices]+ add_parens t+ | isCompoundHsType t = returnL (HsParTy t)+ | otherwise = return t -wrap_apps :: LHsType RdrName -> CvtM (LHsType RdrName)+wrap_apps :: LHsType GhcPs -> CvtM (LHsType GhcPs) wrap_apps t@(L _ HsAppTy {}) = returnL (HsParTy t) wrap_apps t = return t +-- ---------------------------------------------------------------------+-- Note [Adding parens for splices]+{-+The hsSyn representation of parsed source explicitly contains all the original+parens, as written in the source.++When a Template Haskell (TH) splice is evaluated, the original splice is first+renamed and type checked and then finally converted to core in DsMeta. This core+is then run in the TH engine, and the result comes back as a TH AST.++In the process, all parens are stripped out, as they are not needed.++This Convert module then converts the TH AST back to hsSyn AST.++In order to pretty-print this hsSyn AST, parens need to be adde back at certain+points so that the code is readable with its original meaning.++So scattered through Convert.hs are various points where parens are added.++See (among other closed issued) https://ghc.haskell.org/trac/ghc/ticket/14289+-}+-- ---------------------------------------------------------------------+ -- | Constructs an arrow type with a specified return type-mk_arr_apps :: [LHsType RdrName] -> HsType RdrName -> CvtM (LHsType RdrName)+mk_arr_apps :: [LHsType GhcPs] -> HsType GhcPs -> CvtM (LHsType GhcPs) mk_arr_apps tys return_ty = foldrM go return_ty tys >>= returnL- where go :: LHsType RdrName -> HsType RdrName -> CvtM (HsType RdrName)+ where go :: LHsType GhcPs -> HsType GhcPs -> CvtM (HsType GhcPs) go arg ret_ty = do { ret_ty_l <- returnL ret_ty ; return (HsFunTy arg ret_ty_l) } -split_ty_app :: TH.Type -> CvtM (TH.Type, [LHsType RdrName])+split_ty_app :: TH.Type -> CvtM (TH.Type, [LHsType GhcPs]) split_ty_app ty = go ty [] where go (AppT f a) as' = do { a' <- cvtType a; go f (a':as') }@@ -1343,7 +1394,7 @@ {- | @cvtOpAppT x op y@ takes converted arguments and flattens any HsAppsTy structure in them. -}-cvtOpAppT :: LHsType RdrName -> RdrName -> LHsType RdrName -> LHsType RdrName+cvtOpAppT :: LHsType GhcPs -> RdrName -> LHsType GhcPs -> LHsType GhcPs cvtOpAppT t1@(L loc1 _) op t2@(L loc2 _) = L (combineSrcSpans loc1 loc2) $ HsAppsTy (t1' ++ [noLoc $ HsAppInfix (noLoc op)] ++ t2')@@ -1358,21 +1409,21 @@ | otherwise = [noLoc $ HsAppPrefix t2] -cvtKind :: TH.Kind -> CvtM (LHsKind RdrName)+cvtKind :: TH.Kind -> CvtM (LHsKind GhcPs) cvtKind = cvtTypeKind "kind" -- | Convert Maybe Kind to a type family result signature. Used with data -- families where naming of the result is not possible (thus only kind or no -- signature is possible). cvtMaybeKindToFamilyResultSig :: Maybe TH.Kind- -> CvtM (LFamilyResultSig RdrName)+ -> CvtM (LFamilyResultSig GhcPs) cvtMaybeKindToFamilyResultSig Nothing = returnL Hs.NoSig cvtMaybeKindToFamilyResultSig (Just ki) = do { ki' <- cvtKind ki ; returnL (Hs.KindSig ki') } -- | Convert type family result signature. Used with both open and closed type -- families.-cvtFamilyResultSig :: TH.FamilyResultSig -> CvtM (Hs.LFamilyResultSig RdrName)+cvtFamilyResultSig :: TH.FamilyResultSig -> CvtM (Hs.LFamilyResultSig GhcPs) cvtFamilyResultSig TH.NoSig = returnL Hs.NoSig cvtFamilyResultSig (TH.KindSig ki) = do { ki' <- cvtKind ki ; returnL (Hs.KindSig ki') }@@ -1381,13 +1432,13 @@ -- | Convert injectivity annotation of a type family. cvtInjectivityAnnotation :: TH.InjectivityAnn- -> CvtM (Hs.LInjectivityAnn RdrName)+ -> CvtM (Hs.LInjectivityAnn GhcPs) cvtInjectivityAnnotation (TH.InjectivityAnn annLHS annRHS) = do { annLHS' <- tNameL annLHS ; annRHS' <- mapM tNameL annRHS ; returnL (Hs.InjectivityAnn annLHS' annRHS') } -cvtPatSynSigTy :: TH.Type -> CvtM (LHsType RdrName)+cvtPatSynSigTy :: TH.Type -> CvtM (LHsType GhcPs) -- pattern synonym types are of peculiar shapes, which is why we treat -- them separately from regular types; -- see Note [Pattern synonym type signatures and Template Haskell]@@ -1427,9 +1478,6 @@ overloadedLit (IntegerL _) = True overloadedLit (RationalL _) = True overloadedLit _ = False--cvtFractionalLit :: Rational -> FractionalLit-cvtFractionalLit r = FL { fl_text = show (fromRational r :: Double), fl_value = r } -- Checks that are performed when converting unboxed sum expressions and -- patterns alike.
hsSyn/HsBinds.hs view
@@ -17,18 +17,19 @@ module HsBinds where +import GhcPrelude+ import {-# SOURCE #-} HsExpr ( pprExpr, LHsExpr, MatchGroup, pprFunBind, GRHSs, pprPatBind ) import {-# SOURCE #-} HsPat ( LPat ) -import PlaceHolder ( PostTc,PostRn,DataId,OutputableBndrId )+import HsExtension import HsTypes import PprCore () import CoreSyn import TcEvidence import Type-import Name import NameSet import BasicTypes import Outputable@@ -87,8 +88,7 @@ type LHsLocalBindsLR idL idR = Located (HsLocalBindsLR idL idR) -deriving instance (DataId idL, DataId idR)- => Data (HsLocalBindsLR idL idR)+deriving instance (DataId idL, DataId idR) => Data (HsLocalBindsLR idL idR) -- | Haskell Value Bindings type HsValBinds id = HsValBindsLR id id@@ -112,10 +112,9 @@ -- later bindings in the list may depend on earlier ones. | ValBindsOut [(RecFlag, LHsBinds idL)]- [LSig Name]+ [LSig GhcRn] -- AZ: how to do this? -deriving instance (DataId idL, DataId idR)- => Data (HsValBindsLR idL idR)+deriving instance (DataId idL, DataId idR) => Data (HsValBindsLR idL idR) -- | Located Haskell Binding type LHsBind id = LHsBindLR id id@@ -132,9 +131,8 @@ -- | Located Haskell Binding with separate Left and Right identifier types type LHsBindLR idL idR = Located (HsBindLR idL idR) -{- Note [Varieties of binding pattern matches]- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-+{- Note [FunBind vs PatBind]+ ~~~~~~~~~~~~~~~~~~~~~~~~~ The distinction between FunBind and PatBind is a bit subtle. FunBind covers patterns which resemble function bindings and simple variable bindings. @@ -145,13 +143,18 @@ x `f` y = e -- FunRhs has Infix The actual patterns and RHSs of a FunBind are encoding in fun_matches.-The m_ctxt field of Match will be FunRhs and carries two bits of information-about the match,+The m_ctxt field of each Match in fun_matches will be FunRhs and carries+two bits of information about the match, - * the mc_strictness field describes whether the match is decorated with a bang- (e.g. `!x = e`)- * the mc_fixity field describes the fixity of the function binder+ * The mc_fixity field on each Match describes the fixity of the+ function binder in that match. E.g. this is legal:+ f True False = e1+ True `f` True = e2 + * The mc_strictness field is used /only/ for nullary FunBinds: ones+ with one Match, which has no pats. For these, it describes whether+ the match is decorated with a bang (e.g. `!x = e`).+ By contrast, PatBind represents data constructor patterns, as well as a few other interesting cases. Namely, @@ -178,7 +181,7 @@ -- @(f :: a -> a) = ... @ -- -- Strict bindings have their strictness recorded in the 'SrcStrictness' of their- -- 'MatchContext'. See Note [Varieties of binding pattern matches] for+ -- 'MatchContext'. See Note [FunBind vs PatBind] for -- details about the relationship between FunBind and PatBind. -- -- 'ApiAnnotation.AnnKeywordId's@@ -191,7 +194,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation FunBind { - fun_id :: Located idL, -- Note [fun_id in Match] in HsExpr+ fun_id :: Located (IdP idL), -- Note [fun_id in Match] in HsExpr fun_matches :: MatchGroup idR (LHsExpr idR), -- ^ The payload @@ -215,14 +218,14 @@ -- See Note [Bind free vars] - fun_tick :: [Tickish Id] -- ^ Ticks to put on the rhs, if any+ fun_tick :: [Tickish Id] -- ^ Ticks to put on the rhs, if any } -- | Pattern Binding -- -- The pattern is never a simple variable; -- That case is done by FunBind.- -- See Note [Varieties of binding pattern matches] for details about the+ -- See Note [FunBind vs PatBind] for details about the -- relationship between FunBind and PatBind. --@@ -246,7 +249,7 @@ -- Dictionary binding and suchlike. -- All VarBinds are introduced by the type checker | VarBind {- var_id :: idL,+ var_id :: IdP idL, var_rhs :: LHsExpr idR, -- ^ Located only for consistency var_inline :: Bool -- ^ True <=> inline this binding regardless -- (used for implication constraints only)@@ -268,22 +271,9 @@ abs_ev_binds :: [TcEvBinds], -- | Typechecked user bindings- abs_binds :: LHsBinds idL- }-- -- | Abstraction Bindings Signature- | AbsBindsSig { -- Simpler form of AbsBinds, used with a type sig- -- in tcPolyCheck. Produces simpler desugaring and- -- is necessary to avoid #11405, comment:3.- abs_tvs :: [TyVar],- abs_ev_vars :: [EvVar],-- abs_sig_export :: idL, -- like abe_poly- abs_sig_prags :: TcSpecPrags,+ abs_binds :: LHsBinds idL, - abs_sig_ev_bind :: TcEvBinds, -- no list needed here- abs_sig_bind :: LHsBind idL -- always only one, and it's always a- -- FunBind+ abs_sig :: Bool -- See Note [The abs_sig field of AbsBinds] } -- | Patterns Synonym Binding@@ -295,8 +285,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation -deriving instance (DataId idL, DataId idR)- => Data (HsBindLR idL idR)+deriving instance (DataId idL, DataId idR) => Data (HsBindLR idL idR) -- Consider (AbsBinds tvs ds [(ftvs, poly_f, mono_f) binds] --@@ -311,13 +300,14 @@ -- See Note [AbsBinds] -- | Abtraction Bindings Export-data ABExport id- = ABE { abe_poly :: id -- ^ Any INLINE pragmas is attached to this Id- , abe_mono :: id+data ABExport p+ = ABE { abe_poly :: IdP p -- ^ Any INLINE pragma is attached to this Id+ , abe_mono :: IdP p , abe_wrap :: HsWrapper -- ^ See Note [ABExport wrapper] -- Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly , abe_prags :: TcSpecPrags -- ^ SPECIALISE pragmas- } deriving Data+ }+deriving instance (DataId p) => Data (ABExport p) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnPattern', -- 'ApiAnnotation.AnnEqual','ApiAnnotation.AnnLarrow'@@ -328,27 +318,69 @@ -- | Pattern Synonym binding data PatSynBind idL idR- = PSB { psb_id :: Located idL, -- ^ Name of the pattern synonym+ = PSB { psb_id :: Located (IdP idL), -- ^ Name of the pattern synonym psb_fvs :: PostRn idR NameSet, -- ^ See Note [Bind free vars]- psb_args :: HsPatSynDetails (Located idR), -- ^ Formal parameter names- psb_def :: LPat idR, -- ^ Right-hand side- psb_dir :: HsPatSynDir idR -- ^ Directionality+ psb_args :: HsPatSynDetails (Located (IdP idR)),+ -- ^ Formal parameter names+ psb_def :: LPat idR, -- ^ Right-hand side+ psb_dir :: HsPatSynDir idR -- ^ Directionality }-deriving instance (DataId idL, DataId idR)- => Data (PatSynBind idL idR)+deriving instance (DataId idL, DataId idR) => Data (PatSynBind idL idR) {- Note [AbsBinds] ~~~~~~~~~~~~~~~-The AbsBinds constructor is used in the output of the type checker, to record-*typechecked* and *generalised* bindings. Consider a module M, with this-top-level binding, where there is no type signature for M.reverse,+The AbsBinds constructor is used in the output of the type checker, to+record *typechecked* and *generalised* bindings. Specifically++ AbsBinds { abs_tvs = tvs+ , abs_ev_vars = [d1,d2]+ , abs_exports = [ABE { abe_poly = fp, abe_mono = fm+ , abe_wrap = fwrap }+ ABE { slly for g } ]+ , abs_ev_binds = DBINDS+ , abs_binds = BIND[fm,gm] }++where 'BIND' binds the monomorphic Ids 'fm' and 'gm', means++ fp = fwrap [/\ tvs. \d1 d2. letrec { DBINDS ]+ [ ; BIND[fm,gm] } ]+ [ in fm ]++ gp = ...same again, with gm instead of fm++The 'fwrap' is an impedence-matcher that typically does nothing; see+Note [ABExport wrapper].++This is a pretty bad translation, because it duplicates all the bindings.+So the desugarer tries to do a better job:++ fp = /\ [a,b] -> \ [d1,d2] -> case tp [a,b] [d1,d2] of+ (fm,gm) -> fm+ ..ditto for gp..++ tp = /\ [a,b] -> \ [d1,d2] -> letrec { DBINDS; BIND }+ in (fm,gm)++In general:++ * abs_tvs are the type variables over which the binding group is+ generalised+ * abs_ev_var are the evidence variables (usually dictionaries)+ over which the binding group is generalised+ * abs_binds are the monomorphic bindings+ * abs_ex_binds are the evidence bindings that wrap the abs_binds+ * abs_exports connects the monomorphic Ids bound by abs_binds+ with the polymorphic Ids bound by the AbsBinds itself.++For example, consider a module M, with this top-level binding, where+there is no type signature for M.reverse, M.reverse [] = [] M.reverse (x:xs) = M.reverse xs ++ [x] -In Hindley-Milner, a recursive binding is typechecked with the *recursive* uses-being *monomorphic*. So after typechecking *and* desugaring we will get something-like this+In Hindley-Milner, a recursive binding is typechecked with the+*recursive* uses being *monomorphic*. So after typechecking *and*+desugaring we will get something like this M.reverse :: forall a. [a] -> [a] = /\a. letrec@@ -365,19 +397,22 @@ desugaring? That's where AbsBinds comes in. It looks like this: AbsBinds { abs_tvs = [a]+ , abs_ev_vars = [] , abs_exports = [ABE { abe_poly = M.reverse :: forall a. [a] -> [a], , abe_mono = reverse :: [a] -> [a]}]+ , abs_ev_binds = {} , abs_binds = { reverse :: [a] -> [a] = \xs -> case xs of [] -> [] (x:xs) -> reverse xs ++ [x] } } Here,- * abs_tvs says what type variables are abstracted over the binding group,- just 'a' in this case.++ * abs_tvs says what type variables are abstracted over the binding+ group, just 'a' in this case. * abs_binds is the *monomorphic* bindings of the group- * abs_exports describes how to get the polymorphic Id 'M.reverse' from the- monomorphic one 'reverse'+ * abs_exports describes how to get the polymorphic Id 'M.reverse'+ from the monomorphic one 'reverse' Notice that the *original* function (the polymorphic one you thought you were defining) appears in the abe_poly field of the@@ -435,6 +470,53 @@ lacks a user type signature * The group forms a strongly connected component ++Note [The abs_sig field of AbsBinds]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The abs_sig field supports a couple of special cases for bindings.+Consider++ x :: Num a => (# a, a #)+ x = (# 3, 4 #)++The general desugaring for AbsBinds would give++ x = /\a. \ ($dNum :: Num a) ->+ letrec xm = (# fromInteger $dNum 3, fromInteger $dNum 4 #) in+ xm++But that has an illegal let-binding for an unboxed tuple. In this+case we'd prefer to generate the (more direct)++ x = /\ a. \ ($dNum :: Num a) ->+ (# fromInteger $dNum 3, fromInteger $dNum 4 #)++A similar thing happens with representation-polymorphic defns+(Trac #11405):++ undef :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a+ undef = error "undef"++Again, the vanilla desugaring gives a local let-binding for a+representation-polymorphic (undefm :: a), which is illegal. But+again we can desugar without a let:++ undef = /\ a. \ (d:HasCallStack) -> error a d "undef"++The abs_sig field supports this direct desugaring, with no local+let-bining. When abs_sig = True++ * the abs_binds is single FunBind++ * the abs_exports is a singleton++ * we have a complete type sig for binder+ and hence the abs_binds is non-recursive+ (it binds the mono_id but refers to the poly_id++These properties are exploited in DsBinds.dsAbsBinds to+generate code without a let-binding.+ Note [ABExport wrapper] ~~~~~~~~~~~~~~~~~~~~~~~ Consider@@ -478,13 +560,15 @@ it's just an error thunk -} -instance (OutputableBndrId idL, OutputableBndrId idR)+instance (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsLocalBindsLR idL idR) where ppr (HsValBinds bs) = ppr bs ppr (HsIPBinds bs) = ppr bs ppr EmptyLocalBinds = empty -instance (OutputableBndrId idL, OutputableBndrId idR)+instance (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsValBindsLR idL idR) where ppr (ValBindsIn binds sigs) = pprDeclList (pprLHsBindsForUser binds sigs)@@ -500,14 +584,16 @@ pp_rec Recursive = text "rec" pp_rec NonRecursive = text "nonrec" -pprLHsBinds :: (OutputableBndrId idL, OutputableBndrId idR)+pprLHsBinds :: (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR) => LHsBindsLR idL idR -> SDoc pprLHsBinds binds | isEmptyLHsBinds binds = empty | otherwise = pprDeclList (map ppr (bagToList binds)) -pprLHsBindsForUser :: (OutputableBndrId idL, OutputableBndrId idR,- OutputableBndrId id2)+pprLHsBindsForUser :: (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR,+ SourceTextX id2, OutputableBndrId id2) => LHsBindsLR idL idR -> [LSig id2] -> [SDoc] -- pprLHsBindsForUser is different to pprLHsBinds because -- a) No braces: 'let' and 'where' include a list of HsBindGroups@@ -572,37 +658,13 @@ plusHsValBinds _ _ = panic "HsBinds.plusHsValBinds" -{--What AbsBinds means-~~~~~~~~~~~~~~~~~~~- AbsBinds tvs- [d1,d2]- [(tvs1, f1p, f1m),- (tvs2, f2p, f2m)]- BIND-means-- f1p = /\ tvs -> \ [d1,d2] -> letrec DBINDS and BIND- in fm-- gp = ...same again, with gm instead of fm--This is a pretty bad translation, because it duplicates all the bindings.-So the desugarer tries to do a better job:-- fp = /\ [a,b] -> \ [d1,d2] -> case tp [a,b] [d1,d2] of- (fm,gm) -> fm- ..ditto for gp..-- tp = /\ [a,b] -> \ [d1,d2] -> letrec DBINDS and BIND- in (fm,gm)--}--instance (OutputableBndrId idL, OutputableBndrId idR)+instance (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsBindLR idL idR) where ppr mbind = ppr_monobind mbind -ppr_monobind :: (OutputableBndrId idL, OutputableBndrId idR)+ppr_monobind :: (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR) => HsBindLR idL idR -> SDoc ppr_monobind (PatBind { pat_lhs = pat, pat_rhs = grhss })@@ -615,9 +677,9 @@ fun_tick = ticks }) = pprTicks empty (if null ticks then empty else text "-- ticks = " <> ppr ticks)- $$ ifPprDebug (pprBndr LetBind (unLoc fun))+ $$ whenPprDebug (pprBndr LetBind (unLoc fun)) $$ pprFunBind matches- $$ ifPprDebug (ppr wrap)+ $$ whenPprDebug (ppr wrap) ppr_monobind (PatSynBind psb) = ppr psb ppr_monobind (AbsBinds { abs_tvs = tyvars, abs_ev_vars = dictvars , abs_exports = exports, abs_binds = val_binds@@ -636,29 +698,15 @@ , text "Evidence:" <+> ppr ev_binds ] else pprLHsBinds val_binds-ppr_monobind (AbsBindsSig { abs_tvs = tyvars- , abs_ev_vars = dictvars- , abs_sig_export = poly_id- , abs_sig_ev_bind = ev_bind- , abs_sig_bind = bind })- = sdocWithDynFlags $ \ dflags ->- if gopt Opt_PrintTypecheckerElaboration dflags then- hang (text "AbsBindsSig" <+> brackets (interpp'SP tyvars)- <+> brackets (interpp'SP dictvars))- 2 $ braces $ vcat- [ text "Exported type:" <+> pprBndr LetBind poly_id- , text "Bind:" <+> ppr bind- , text "Evidence:" <+> ppr ev_bind ]- else- ppr bind -instance (OutputableBndr id) => Outputable (ABExport id) where+instance (OutputableBndrId p) => Outputable (ABExport p) where ppr (ABE { abe_wrap = wrap, abe_poly = gbl, abe_mono = lcl, abe_prags = prags }) = vcat [ ppr gbl <+> text "<=" <+> ppr lcl , nest 2 (pprTcSpecPrags prags) , nest 2 (text "wrap:" <+> ppr wrap)] -instance (OutputableBndr idL, OutputableBndrId idR)+instance (SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR) => Outputable (PatSynBind idL idR) where ppr (PSB{ psb_id = (L _ psyn), psb_args = details, psb_def = pat, psb_dir = dir })@@ -668,11 +716,10 @@ ppr_simple syntax = syntax <+> ppr pat ppr_details = case details of- InfixPatSyn v1 v2 -> hsep [ppr v1, pprInfixOcc psyn, ppr v2]- PrefixPatSyn vs -> hsep (pprPrefixOcc psyn : map ppr vs)- RecordPatSyn vs ->- pprPrefixOcc psyn- <> braces (sep (punctuate comma (map ppr vs)))+ InfixCon v1 v2 -> hsep [ppr v1, pprInfixOcc psyn, ppr v2]+ PrefixCon vs -> hsep (pprPrefixOcc psyn : map ppr vs)+ RecCon vs -> pprPrefixOcc psyn+ <> braces (sep (punctuate comma (map ppr vs))) ppr_rhs = case dir of Unidirectional -> ppr_simple (text "<-")@@ -727,14 +774,14 @@ -- For details on above see note [Api annotations] in ApiAnnotation data IPBind id- = IPBind (Either (Located HsIPName) id) (LHsExpr id)+ = IPBind (Either (Located HsIPName) (IdP id)) (LHsExpr id) deriving instance (DataId name) => Data (IPBind name) -instance (OutputableBndrId id ) => Outputable (HsIPBinds id) where+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsIPBinds p) where ppr (IPBinds bs ds) = pprDeeperList vcat (map ppr bs)- $$ ifPprDebug (ppr ds)+ $$ whenPprDebug (ppr ds) -instance (OutputableBndrId id ) => Outputable (IPBind id) where+instance (SourceTextX p, OutputableBndrId p ) => Outputable (IPBind p) where ppr (IPBind lr rhs) = name <+> equals <+> pprExpr (unLoc rhs) where name = case lr of Left (L _ ip) -> pprBndr LetBind ip@@ -754,10 +801,10 @@ -} -- | Located Signature-type LSig name = Located (Sig name)+type LSig pass = Located (Sig pass) -- | Signatures and pragmas-data Sig name+data Sig pass = -- | An ordinary type signature -- -- > f :: Num a => a -> a@@ -775,8 +822,8 @@ -- For details on above see note [Api annotations] in ApiAnnotation TypeSig- [Located name] -- LHS of the signature; e.g. f,g,h :: blah- (LHsSigWcType name) -- RHS of the signature; can have wildcards+ [Located (IdP pass)] -- LHS of the signature; e.g. f,g,h :: blah+ (LHsSigWcType pass) -- RHS of the signature; can have wildcards -- | A pattern synonym type signature --@@ -787,7 +834,7 @@ -- 'ApiAnnotation.AnnDot','ApiAnnotation.AnnDarrow' -- For details on above see note [Api annotations] in ApiAnnotation- | PatSynSig [Located name] (LHsSigType name)+ | PatSynSig [Located (IdP pass)] (LHsSigType pass) -- P :: forall a b. Req => Prov => ty -- | A signature for a class method@@ -800,7 +847,7 @@ -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDefault', -- 'ApiAnnotation.AnnDcolon'- | ClassOpSig Bool [Located name] (LHsSigType name)+ | ClassOpSig Bool [Located (IdP pass)] (LHsSigType pass) -- | A type signature in generated code, notably the code -- generated for record selectors. We simply record@@ -818,7 +865,7 @@ -- 'ApiAnnotation.AnnVal' -- For details on above see note [Api annotations] in ApiAnnotation- | FixSig (FixitySig name)+ | FixSig (FixitySig pass) -- | An inline pragma --@@ -831,8 +878,8 @@ -- 'ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation- | InlineSig (Located name) -- Function name- InlinePragma -- Never defaultInlinePragma+ | InlineSig (Located (IdP pass)) -- Function name+ InlinePragma -- Never defaultInlinePragma -- | A specialisation pragma --@@ -846,8 +893,8 @@ -- 'ApiAnnotation.AnnDcolon' -- For details on above see note [Api annotations] in ApiAnnotation- | SpecSig (Located name) -- Specialise a function or datatype ...- [LHsSigType name] -- ... to these types+ | SpecSig (Located (IdP pass)) -- Specialise a function or datatype ...+ [LHsSigType pass] -- ... to these types InlinePragma -- The pragma on SPECIALISE_INLINE form. -- If it's just defaultInlinePragma, then we said -- SPECIALISE, not SPECIALISE_INLINE@@ -863,7 +910,7 @@ -- 'ApiAnnotation.AnnInstance','ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation- | SpecInstSig SourceText (LHsSigType name)+ | SpecInstSig SourceText (LHsSigType pass) -- Note [Pragma source text] in BasicTypes -- | A minimal complete definition pragma@@ -875,7 +922,7 @@ -- 'ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation- | MinimalSig SourceText (LBooleanFormula (Located name))+ | MinimalSig SourceText (LBooleanFormula (Located (IdP pass))) -- Note [Pragma source text] in BasicTypes -- | A "set cost centre" pragma for declarations@@ -887,7 +934,7 @@ -- > {-# SCC funName "cost_centre_name" #-} | SCCFunSig SourceText -- Note [Pragma source text] in BasicTypes- (Located name) -- Function name+ (Located (IdP pass)) -- Function name (Maybe (Located StringLiteral)) -- | A complete match pragma --@@ -896,16 +943,18 @@ -- Used to inform the pattern match checker about additional -- complete matchings which, for example, arise from pattern -- synonym definitions.- | CompleteMatchSig SourceText (Located [Located name]) (Maybe (Located name))+ | CompleteMatchSig SourceText+ (Located [Located (IdP pass)])+ (Maybe (Located (IdP pass))) -deriving instance (DataId name) => Data (Sig name)+deriving instance (DataId pass) => Data (Sig pass) -- | Located Fixity Signature-type LFixitySig name = Located (FixitySig name)+type LFixitySig pass = Located (FixitySig pass) -- | Fixity Signature-data FixitySig name = FixitySig [Located name] Fixity- deriving Data+data FixitySig pass = FixitySig [Located (IdP pass)] Fixity+deriving instance (DataId pass) => Data (FixitySig pass) -- | Type checker Specialisation Pragmas --@@ -925,7 +974,7 @@ Id HsWrapper InlinePragma- -- ^ The Id to be specialised, an wrapper that specialises the+ -- ^ The Id to be specialised, a wrapper that specialises the -- polymorphic function, and inlining spec for the specialised function deriving Data @@ -1005,10 +1054,11 @@ equality is not enough -- we have to check if they overlap. -} -instance (OutputableBndrId name ) => Outputable (Sig name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (Sig pass) where ppr sig = ppr_sig sig -ppr_sig :: (OutputableBndrId name ) => Sig name -> SDoc+ppr_sig :: (SourceTextX pass, OutputableBndrId pass ) => Sig pass -> SDoc ppr_sig (TypeSig vars ty) = pprVarSig (map unLoc vars) (ppr ty) ppr_sig (ClassOpSig is_deflt vars ty) | is_deflt = text "default" <+> pprVarSig (map unLoc vars) (ppr ty)@@ -1020,8 +1070,8 @@ (interpp'SP ty) inl) where pragmaSrc = case spec of- EmptyInlineSpec -> "{-# SPECIALISE"- _ -> "{-# SPECIALISE_INLINE"+ NoUserInline -> "{-# SPECIALISE"+ _ -> "{-# SPECIALISE_INLINE" ppr_sig (InlineSig var inl) = pragSrcBrackets (inl_src inl) "{-# INLINE" (pprInline inl <+> pprPrefixOcc (unLoc var))@@ -1040,7 +1090,7 @@ where opt_sig = maybe empty ((\t -> dcolon <+> ppr t) . unLoc) mty -instance OutputableBndr name => Outputable (FixitySig name) where+instance OutputableBndrId pass => Outputable (FixitySig pass) where ppr (FixitySig names fixity) = sep [ppr fixity, pprops] where pprops = hsep $ punctuate comma (map (pprInfixOcc . unLoc) names)@@ -1086,12 +1136,7 @@ -} -- | Haskell Pattern Synonym Details-data HsPatSynDetails a- = InfixPatSyn a a -- ^ Infix Pattern Synonym- | PrefixPatSyn [a] -- ^ Prefix Pattern Synonym- | RecordPatSyn [RecordPatSynField a] -- ^ Record Pattern Synonym- deriving Data-+type HsPatSynDetails arg = HsConDetails arg [RecordPatSynField arg] -- See Note [Record PatSyn Fields] -- | Record Pattern Synonym Field@@ -1147,43 +1192,6 @@ , recordPatSynPatVar = pat_var }) <$> f visible <*> f hidden --instance Functor HsPatSynDetails where- fmap f (InfixPatSyn left right) = InfixPatSyn (f left) (f right)- fmap f (PrefixPatSyn args) = PrefixPatSyn (fmap f args)- fmap f (RecordPatSyn args) = RecordPatSyn (map (fmap f) args)--instance Foldable HsPatSynDetails where- foldMap f (InfixPatSyn left right) = f left `mappend` f right- foldMap f (PrefixPatSyn args) = foldMap f args- foldMap f (RecordPatSyn args) = foldMap (foldMap f) args-- foldl1 f (InfixPatSyn left right) = left `f` right- foldl1 f (PrefixPatSyn args) = Data.List.foldl1 f args- foldl1 f (RecordPatSyn args) =- Data.List.foldl1 f (map (Data.Foldable.foldl1 f) args)-- foldr1 f (InfixPatSyn left right) = left `f` right- foldr1 f (PrefixPatSyn args) = Data.List.foldr1 f args- foldr1 f (RecordPatSyn args) =- Data.List.foldr1 f (map (Data.Foldable.foldr1 f) args)-- length (InfixPatSyn _ _) = 2- length (PrefixPatSyn args) = Data.List.length args- length (RecordPatSyn args) = Data.List.length args-- null (InfixPatSyn _ _) = False- null (PrefixPatSyn args) = Data.List.null args- null (RecordPatSyn args) = Data.List.null args-- toList (InfixPatSyn left right) = [left, right]- toList (PrefixPatSyn args) = args- toList (RecordPatSyn args) = foldMap toList args--instance Traversable HsPatSynDetails where- traverse f (InfixPatSyn left right) = InfixPatSyn <$> f left <*> f right- traverse f (PrefixPatSyn args) = PrefixPatSyn <$> traverse f args- traverse f (RecordPatSyn args) = RecordPatSyn <$> traverse (traverse f) args -- | Haskell Pattern Synonym Direction data HsPatSynDir id
hsSyn/HsDecls.hs view
@@ -37,8 +37,9 @@ -- ** Instance declarations InstDecl(..), LInstDecl, NewOrData(..), FamilyInfo(..), TyFamInstDecl(..), LTyFamInstDecl, instDeclDataFamInsts,- DataFamInstDecl(..), LDataFamInstDecl, pprDataFamInstFlavour,- TyFamEqn(..), TyFamInstEqn, LTyFamInstEqn, TyFamDefltEqn, LTyFamDefltEqn,+ DataFamInstDecl(..), LDataFamInstDecl, pprDataFamInstFlavour, pprFamInstLHS,+ FamInstEqn, LFamInstEqn, FamEqn(..),+ TyFamInstEqn, LTyFamInstEqn, TyFamDefltEqn, LTyFamDefltEqn, HsTyPats, LClsInstDecl, ClsInstDecl(..), @@ -86,6 +87,8 @@ ) where -- friends:+import GhcPrelude+ import {-# SOURCE #-} HsExpr( LHsExpr, HsExpr, HsSplice, pprExpr, pprSpliceDecl ) -- Because Expr imports Decls via HsBracket@@ -98,7 +101,8 @@ import BasicTypes import Coercion import ForeignCall-import PlaceHolder ( PostTc,PostRn,PlaceHolder(..),DataId, OutputableBndrId )+import PlaceHolder ( PlaceHolder(..) )+import HsExtension import NameSet -- others:@@ -251,7 +255,8 @@ hs_vects = vects1 ++ vects2, hs_docs = docs1 ++ docs2 } -instance (OutputableBndrId name) => Outputable (HsDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsDecl pass) where ppr (TyClD dcl) = ppr dcl ppr (ValD binds) = ppr binds ppr (DefD def) = ppr def@@ -267,7 +272,8 @@ ppr (DocD doc) = ppr doc ppr (RoleAnnotD ra) = ppr ra -instance (OutputableBndrId name) => Outputable (HsGroup name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsGroup pass) where ppr (HsGroup { hs_valds = val_decls, hs_tyclds = tycl_decls, hs_derivds = deriv_decls,@@ -302,7 +308,7 @@ vcat_mb gap (Just d : ds) = gap $$ d $$ vcat_mb blankLine ds -- | Located Splice Declaration-type LSpliceDecl name = Located (SpliceDecl name)+type LSpliceDecl pass = Located (SpliceDecl pass) -- | Splice Declaration data SpliceDecl id@@ -311,7 +317,8 @@ SpliceExplicitFlag deriving instance (DataId id) => Data (SpliceDecl id) -instance (OutputableBndrId name) => Outputable (SpliceDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (SpliceDecl pass) where ppr (SpliceDecl (L _ e) f) = pprSpliceDecl e f {-@@ -454,10 +461,10 @@ -} -- | Located Declaration of a Type or Class-type LTyClDecl name = Located (TyClDecl name)+type LTyClDecl pass = Located (TyClDecl pass) -- | A type or class declaration.-data TyClDecl name+data TyClDecl pass = -- | @type/data family T :: *->*@ -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType',@@ -469,7 +476,7 @@ -- 'ApiAnnotation.AnnVbar' -- For details on above see note [Api annotations] in ApiAnnotation- FamDecl { tcdFam :: FamilyDecl name }+ FamDecl { tcdFam :: FamilyDecl pass } | -- | @type@ declaration --@@ -477,12 +484,13 @@ -- 'ApiAnnotation.AnnEqual', -- For details on above see note [Api annotations] in ApiAnnotation- SynDecl { tcdLName :: Located name -- ^ Type constructor- , tcdTyVars :: LHsQTyVars name -- ^ Type variables; for an associated type- -- these include outer binders+ SynDecl { tcdLName :: Located (IdP pass) -- ^ Type constructor+ , tcdTyVars :: LHsQTyVars pass -- ^ Type variables; for an+ -- associated type these+ -- include outer binders , tcdFixity :: LexicalFixity -- ^ Fixity used in the declaration- , tcdRhs :: LHsType name -- ^ RHS of type declaration- , tcdFVs :: PostRn name NameSet }+ , tcdRhs :: LHsType pass -- ^ RHS of type declaration+ , tcdFVs :: PostRn pass NameSet } | -- | @data@ declaration --@@ -493,31 +501,33 @@ -- 'ApiAnnotation.AnnWhere', -- For details on above see note [Api annotations] in ApiAnnotation- DataDecl { tcdLName :: Located name -- ^ Type constructor- , tcdTyVars :: LHsQTyVars name -- ^ Type variables; for an associated type- -- these include outer binders- -- Eg class T a where- -- type F a :: *- -- type F a = a -> a- -- Here the type decl for 'f' includes 'a'- -- in its tcdTyVars+ DataDecl { tcdLName :: Located (IdP pass) -- ^ Type constructor+ , tcdTyVars :: LHsQTyVars pass -- ^ Type variables; for an+ -- associated type+ -- these include outer binders+ -- Eg class T a where+ -- type F a :: *+ -- type F a = a -> a+ -- Here the type decl for 'f'+ -- includes 'a' in its tcdTyVars , tcdFixity :: LexicalFixity -- ^ Fixity used in the declaration- , tcdDataDefn :: HsDataDefn name- , tcdDataCusk :: PostRn name Bool -- ^ does this have a CUSK?- , tcdFVs :: PostRn name NameSet }+ , tcdDataDefn :: HsDataDefn pass+ , tcdDataCusk :: PostRn pass Bool -- ^ does this have a CUSK?+ , tcdFVs :: PostRn pass NameSet } - | ClassDecl { tcdCtxt :: LHsContext name, -- ^ Context...- tcdLName :: Located name, -- ^ Name of the class- tcdTyVars :: LHsQTyVars name, -- ^ Class type variables+ | ClassDecl { tcdCtxt :: LHsContext pass, -- ^ Context...+ tcdLName :: Located (IdP pass), -- ^ Name of the class+ tcdTyVars :: LHsQTyVars pass, -- ^ Class type variables tcdFixity :: LexicalFixity, -- ^ Fixity used in the declaration- tcdFDs :: [Located (FunDep (Located name))],+ tcdFDs :: [Located (FunDep (Located (IdP pass)))], -- ^ Functional deps- tcdSigs :: [LSig name], -- ^ Methods' signatures- tcdMeths :: LHsBinds name, -- ^ Default methods- tcdATs :: [LFamilyDecl name], -- ^ Associated types;- tcdATDefs :: [LTyFamDefltEqn name], -- ^ Associated type defaults+ tcdSigs :: [LSig pass], -- ^ Methods' signatures+ tcdMeths :: LHsBinds pass, -- ^ Default methods+ tcdATs :: [LFamilyDecl pass], -- ^ Associated types;+ tcdATDefs :: [LTyFamDefltEqn pass],+ -- ^ Associated type defaults tcdDocs :: [LDocDecl], -- ^ Haddock docs- tcdFVs :: PostRn name NameSet+ tcdFVs :: PostRn pass NameSet } -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnClass', -- 'ApiAnnotation.AnnWhere','ApiAnnotation.AnnOpen',@@ -536,27 +546,27 @@ -- | @True@ <=> argument is a @data@\/@newtype@ -- declaration.-isDataDecl :: TyClDecl name -> Bool+isDataDecl :: TyClDecl pass -> Bool isDataDecl (DataDecl {}) = True isDataDecl _other = False -- | type or type instance declaration-isSynDecl :: TyClDecl name -> Bool+isSynDecl :: TyClDecl pass -> Bool isSynDecl (SynDecl {}) = True isSynDecl _other = False -- | type class-isClassDecl :: TyClDecl name -> Bool+isClassDecl :: TyClDecl pass -> Bool isClassDecl (ClassDecl {}) = True isClassDecl _ = False -- | type/data family declaration-isFamilyDecl :: TyClDecl name -> Bool+isFamilyDecl :: TyClDecl pass -> Bool isFamilyDecl (FamDecl {}) = True isFamilyDecl _other = False -- | type family declaration-isTypeFamilyDecl :: TyClDecl name -> Bool+isTypeFamilyDecl :: TyClDecl pass -> Bool isTypeFamilyDecl (FamDecl (FamilyDecl { fdInfo = info })) = case info of OpenTypeFamily -> True ClosedTypeFamily {} -> True@@ -564,42 +574,42 @@ isTypeFamilyDecl _ = False -- | open type family info-isOpenTypeFamilyInfo :: FamilyInfo name -> Bool+isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool isOpenTypeFamilyInfo OpenTypeFamily = True isOpenTypeFamilyInfo _ = False -- | closed type family info-isClosedTypeFamilyInfo :: FamilyInfo name -> Bool+isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool isClosedTypeFamilyInfo (ClosedTypeFamily {}) = True isClosedTypeFamilyInfo _ = False -- | data family declaration-isDataFamilyDecl :: TyClDecl name -> Bool+isDataFamilyDecl :: TyClDecl pass -> Bool isDataFamilyDecl (FamDecl (FamilyDecl { fdInfo = DataFamily })) = True isDataFamilyDecl _other = False -- Dealing with names -tyFamInstDeclName :: TyFamInstDecl name -> name+tyFamInstDeclName :: TyFamInstDecl pass -> (IdP pass) tyFamInstDeclName = unLoc . tyFamInstDeclLName -tyFamInstDeclLName :: TyFamInstDecl name -> Located name+tyFamInstDeclLName :: TyFamInstDecl pass -> Located (IdP pass) tyFamInstDeclLName (TyFamInstDecl { tfid_eqn =- (L _ (TyFamEqn { tfe_tycon = ln })) })+ (HsIB { hsib_body = FamEqn { feqn_tycon = ln }}) }) = ln -tyClDeclLName :: TyClDecl name -> Located name+tyClDeclLName :: TyClDecl pass -> Located (IdP pass) tyClDeclLName (FamDecl { tcdFam = FamilyDecl { fdLName = ln } }) = ln tyClDeclLName decl = tcdLName decl -tcdName :: TyClDecl name -> name+tcdName :: TyClDecl pass -> (IdP pass) tcdName = unLoc . tyClDeclLName -tyClDeclTyVars :: TyClDecl name -> LHsQTyVars name+tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass tyClDeclTyVars (FamDecl { tcdFam = FamilyDecl { fdTyVars = tvs } }) = tvs tyClDeclTyVars d = tcdTyVars d -countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int)+countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int) -- class, synonym decls, data, newtype, family decls countTyClDecls decls = (count isClassDecl decls,@@ -616,7 +626,7 @@ -- | Does this declaration have a complete, user-supplied kind signature? -- See Note [Complete user-supplied kind signatures]-hsDeclHasCusk :: TyClDecl Name -> Bool+hsDeclHasCusk :: TyClDecl GhcRn -> Bool hsDeclHasCusk (FamDecl { tcdFam = fam_decl }) = famDeclHasCusk Nothing fam_decl hsDeclHasCusk (SynDecl { tcdTyVars = tyvars, tcdRhs = rhs }) -- NB: Keep this synchronized with 'getInitialKind'@@ -632,7 +642,8 @@ -- Pretty-printing TyClDecl -- ~~~~~~~~~~~~~~~~~~~~~~~~ -instance (OutputableBndrId name) => Outputable (TyClDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (TyClDecl pass) where ppr (FamDecl { tcdFam = decl }) = ppr decl ppr (SynDecl { tcdLName = ltycon, tcdTyVars = tyvars, tcdFixity = fixity@@ -663,7 +674,8 @@ <+> pp_vanilla_decl_head lclas tyvars fixity (unLoc context) <+> pprFundeps (map unLoc fds) -instance (OutputableBndrId name) => Outputable (TyClGroup name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (TyClGroup pass) where ppr (TyClGroup { group_tyclds = tyclds , group_roles = roles , group_instds = instds@@ -673,15 +685,20 @@ ppr roles $$ ppr instds -pp_vanilla_decl_head :: (OutputableBndrId name) => Located name- -> LHsQTyVars name+pp_vanilla_decl_head :: (SourceTextX pass, OutputableBndrId pass)+ => Located (IdP pass)+ -> LHsQTyVars pass -> LexicalFixity- -> HsContext name+ -> HsContext pass -> SDoc pp_vanilla_decl_head thing (HsQTvs { hsq_explicit = tyvars }) fixity context = hsep [pprHsContext context, pp_tyvars tyvars] where pp_tyvars (varl:varsr)+ | fixity == Infix && length varsr > 1+ = hsep [char '(',ppr (unLoc varl), pprInfixOcc (unLoc thing)+ , (ppr.unLoc) (head varsr), char ')'+ , hsep (map (ppr.unLoc) (tail varsr))] | fixity == Infix = hsep [ppr (unLoc varl), pprInfixOcc (unLoc thing) , hsep (map (ppr.unLoc) varsr)]@@ -762,25 +779,25 @@ -} -- | Type or Class Group-data TyClGroup name -- See Note [TyClGroups and dependency analysis]- = TyClGroup { group_tyclds :: [LTyClDecl name]- , group_roles :: [LRoleAnnotDecl name]- , group_instds :: [LInstDecl name] }+data TyClGroup pass -- See Note [TyClGroups and dependency analysis]+ = TyClGroup { group_tyclds :: [LTyClDecl pass]+ , group_roles :: [LRoleAnnotDecl pass]+ , group_instds :: [LInstDecl pass] } deriving instance (DataId id) => Data (TyClGroup id) -emptyTyClGroup :: TyClGroup name+emptyTyClGroup :: TyClGroup pass emptyTyClGroup = TyClGroup [] [] [] -tyClGroupTyClDecls :: [TyClGroup name] -> [LTyClDecl name]+tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass] tyClGroupTyClDecls = concatMap group_tyclds -tyClGroupInstDecls :: [TyClGroup name] -> [LInstDecl name]+tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass] tyClGroupInstDecls = concatMap group_instds -tyClGroupRoleDecls :: [TyClGroup name] -> [LRoleAnnotDecl name]+tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass] tyClGroupRoleDecls = concatMap group_roles -mkTyClGroup :: [LTyClDecl name] -> [LInstDecl name] -> TyClGroup name+mkTyClGroup :: [LTyClDecl pass] -> [LInstDecl pass] -> TyClGroup pass mkTyClGroup decls instds = TyClGroup { group_tyclds = decls , group_roles = []@@ -859,42 +876,42 @@ -} -- | Located type Family Result Signature-type LFamilyResultSig name = Located (FamilyResultSig name)+type LFamilyResultSig pass = Located (FamilyResultSig pass) -- | type Family Result Signature-data FamilyResultSig name = -- see Note [FamilyResultSig]+data FamilyResultSig pass = -- see Note [FamilyResultSig] NoSig -- ^ - 'ApiAnnotation.AnnKeywordId' : -- For details on above see note [Api annotations] in ApiAnnotation - | KindSig (LHsKind name)+ | KindSig (LHsKind pass) -- ^ - 'ApiAnnotation.AnnKeywordId' : -- 'ApiAnnotation.AnnOpenP','ApiAnnotation.AnnDcolon', -- 'ApiAnnotation.AnnCloseP' -- For details on above see note [Api annotations] in ApiAnnotation - | TyVarSig (LHsTyVarBndr name)+ | TyVarSig (LHsTyVarBndr pass) -- ^ - 'ApiAnnotation.AnnKeywordId' : -- 'ApiAnnotation.AnnOpenP','ApiAnnotation.AnnDcolon', -- 'ApiAnnotation.AnnCloseP', 'ApiAnnotation.AnnEqual' -- For details on above see note [Api annotations] in ApiAnnotation -deriving instance (DataId name) => Data (FamilyResultSig name)+deriving instance (DataId pass) => Data (FamilyResultSig pass) -- | Located type Family Declaration-type LFamilyDecl name = Located (FamilyDecl name)+type LFamilyDecl pass = Located (FamilyDecl pass) -- | type Family Declaration-data FamilyDecl name = FamilyDecl- { fdInfo :: FamilyInfo name -- type/data, closed/open- , fdLName :: Located name -- type constructor- , fdTyVars :: LHsQTyVars name -- type variables+data FamilyDecl pass = FamilyDecl+ { fdInfo :: FamilyInfo pass -- type/data, closed/open+ , fdLName :: Located (IdP pass) -- type constructor+ , fdTyVars :: LHsQTyVars pass -- type variables , fdFixity :: LexicalFixity -- Fixity used in the declaration- , fdResultSig :: LFamilyResultSig name -- result signature- , fdInjectivityAnn :: Maybe (LInjectivityAnn name) -- optional injectivity ann+ , fdResultSig :: LFamilyResultSig pass -- result signature+ , fdInjectivityAnn :: Maybe (LInjectivityAnn pass) -- optional injectivity ann } -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType', -- 'ApiAnnotation.AnnData', 'ApiAnnotation.AnnFamily',@@ -908,7 +925,7 @@ deriving instance (DataId id) => Data (FamilyDecl id) -- | Located Injectivity Annotation-type LInjectivityAnn name = Located (InjectivityAnn name)+type LInjectivityAnn pass = Located (InjectivityAnn pass) -- | If the user supplied an injectivity annotation it is represented using -- InjectivityAnn. At the moment this is a single injectivity condition - see@@ -918,26 +935,26 @@ -- type family Foo a b c = r | r -> a c where ... -- -- This will be represented as "InjectivityAnn `r` [`a`, `c`]"-data InjectivityAnn name- = InjectivityAnn (Located name) [Located name]+data InjectivityAnn pass+ = InjectivityAnn (Located (IdP pass)) [Located (IdP pass)] -- ^ - 'ApiAnnotation.AnnKeywordId' : -- 'ApiAnnotation.AnnRarrow', 'ApiAnnotation.AnnVbar' -- For details on above see note [Api annotations] in ApiAnnotation- deriving Data+deriving instance (DataId pass) => Data (InjectivityAnn pass) -data FamilyInfo name+data FamilyInfo pass = DataFamily | OpenTypeFamily -- | 'Nothing' if we're in an hs-boot file and the user -- said "type family Foo x where .."- | ClosedTypeFamily (Maybe [LTyFamInstEqn name])-deriving instance (DataId name) => Data (FamilyInfo name)+ | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])+deriving instance (DataId pass) => Data (FamilyInfo pass) -- | Does this family declaration have a complete, user-supplied kind signature? famDeclHasCusk :: Maybe Bool -- ^ if associated, does the enclosing class have a CUSK?- -> FamilyDecl name -> Bool+ -> FamilyDecl pass -> Bool famDeclHasCusk _ (FamilyDecl { fdInfo = ClosedTypeFamily _ , fdTyVars = tyvars , fdResultSig = L _ resultSig })@@ -952,15 +969,16 @@ hasReturnKindSignature _ = True -- | Maybe return name of the result type variable-resultVariableName :: FamilyResultSig a -> Maybe a+resultVariableName :: FamilyResultSig a -> Maybe (IdP a) resultVariableName (TyVarSig sig) = Just $ hsLTyVarName sig resultVariableName _ = Nothing -instance (OutputableBndrId name) => Outputable (FamilyDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (FamilyDecl pass) where ppr = pprFamilyDecl TopLevel -pprFamilyDecl :: (OutputableBndrId name)- => TopLevelFlag -> FamilyDecl name -> SDoc+pprFamilyDecl :: (SourceTextX pass, OutputableBndrId pass)+ => TopLevelFlag -> FamilyDecl pass -> SDoc pprFamilyDecl top_level (FamilyDecl { fdInfo = info, fdLName = ltycon , fdTyVars = tyvars , fdFixity = fixity@@ -988,15 +1006,15 @@ ( text "where" , case mb_eqns of Nothing -> text ".."- Just eqns -> vcat $ map ppr_fam_inst_eqn eqns )+ Just eqns -> vcat $ map (ppr_fam_inst_eqn . unLoc) eqns ) _ -> (empty, empty) -pprFlavour :: FamilyInfo name -> SDoc+pprFlavour :: FamilyInfo pass -> SDoc pprFlavour DataFamily = text "data" pprFlavour OpenTypeFamily = text "type" pprFlavour (ClosedTypeFamily {}) = text "type" -instance Outputable (FamilyInfo name) where+instance Outputable (FamilyInfo pass) where ppr info = pprFlavour info <+> text "family" @@ -1008,7 +1026,7 @@ ********************************************************************* -} -- | Haskell Data type Definition-data HsDataDefn name -- The payload of a data type defn+data HsDataDefn pass -- The payload of a data type defn -- Used *both* for vanilla data declarations, -- *and* for data family instances = -- | Declares a data type or newtype, giving its constructors@@ -1017,9 +1035,9 @@ -- data/newtype instance T [a] = <constrs> -- @ HsDataDefn { dd_ND :: NewOrData,- dd_ctxt :: LHsContext name, -- ^ Context+ dd_ctxt :: LHsContext pass, -- ^ Context dd_cType :: Maybe (Located CType),- dd_kindSig:: Maybe (LHsKind name),+ dd_kindSig:: Maybe (LHsKind pass), -- ^ Optional kind signature. -- -- @(Just k)@ for a GADT-style @data@,@@ -1027,7 +1045,7 @@ -- -- Always @Nothing@ for H98-syntax decls - dd_cons :: [LConDecl name],+ dd_cons :: [LConDecl pass], -- ^ Data constructors -- -- For @data T a = T1 | T2 a@@@ -1035,14 +1053,14 @@ -- For @data T a where { T1 :: T a }@ -- the 'LConDecls' all have 'ConDeclGADT'. - dd_derivs :: HsDeriving name -- ^ Optional 'deriving' claues+ dd_derivs :: HsDeriving pass -- ^ Optional 'deriving' claues -- For details on above see note [Api annotations] in ApiAnnotation } deriving instance (DataId id) => Data (HsDataDefn id) -- | Haskell Deriving clause-type HsDeriving name = Located [LHsDerivingClause name]+type HsDeriving pass = Located [LHsDerivingClause pass] -- ^ The optional @deriving@ clauses of a data declaration. "Clauses" is -- plural because one can specify multiple deriving clauses using the -- @-XDerivingStrategies@ language extension.@@ -1051,7 +1069,7 @@ -- requested to derive, in order. If no deriving clauses were specified, -- the list is empty. -type LHsDerivingClause name = Located (HsDerivingClause name)+type LHsDerivingClause pass = Located (HsDerivingClause pass) -- | A single @deriving@ clause of a data declaration. --@@ -1059,13 +1077,13 @@ -- 'ApiAnnotation.AnnDeriving', 'ApiAnnotation.AnnStock', -- 'ApiAnnotation.AnnAnyClass', 'Api.AnnNewtype', -- 'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose'-data HsDerivingClause name+data HsDerivingClause pass -- See Note [Deriving strategies] in TcDeriv = HsDerivingClause { deriv_clause_strategy :: Maybe (Located DerivStrategy) -- ^ The user-specified strategy (if any) to use when deriving -- 'deriv_clause_tys'.- , deriv_clause_tys :: Located [LHsSigType name]+ , deriv_clause_tys :: Located [LHsSigType pass] -- ^ The types to derive. -- -- It uses 'LHsSigType's because, with @-XGeneralizedNewtypeDeriving@,@@ -1077,8 +1095,8 @@ } deriving instance (DataId id) => Data (HsDerivingClause id) -instance (OutputableBndrId name)- => Outputable (HsDerivingClause name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsDerivingClause pass) where ppr (HsDerivingClause { deriv_clause_strategy = dcs , deriv_clause_tys = L _ dct }) = hsep [ text "deriving"@@ -1088,8 +1106,9 @@ -- This complexity is to distinguish between -- deriving Show -- deriving (Show)- pp_dct [a@(HsIB { hsib_body = L _ HsAppsTy{} })] = parens (ppr a)- pp_dct [a] = ppr a+ pp_dct [a@(HsIB { hsib_body = ty })]+ | isCompoundHsType ty = parens (ppr a)+ | otherwise = ppr a pp_dct _ = parens (interpp'SP dct) data NewOrData@@ -1098,7 +1117,7 @@ deriving( Eq, Data ) -- Needed because Demand derives Eq -- | Located data Constructor Declaration-type LConDecl name = Located (ConDecl name)+type LConDecl pass = Located (ConDecl pass) -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when -- in a GADT constructor list @@ -1129,57 +1148,57 @@ -- For details on above see note [Api annotations] in ApiAnnotation -- | data Constructor Declaration-data ConDecl name+data ConDecl pass = ConDeclGADT- { con_names :: [Located name]- , con_type :: LHsSigType name+ { con_names :: [Located (IdP pass)]+ , con_type :: LHsSigType pass -- ^ The type after the ‘::’ , con_doc :: Maybe LHsDocString -- ^ A possible Haddock comment. } | ConDeclH98- { con_name :: Located name+ { con_name :: Located (IdP pass) - , con_qvars :: Maybe (LHsQTyVars name)+ , con_qvars :: Maybe (LHsQTyVars pass) -- User-written forall (if any), and its implicit -- kind variables- -- Non-Nothing needs -XExistentialQuantification- -- e.g. data T a = forall b. MkT b (b->a)- -- con_qvars = {b}+ -- Non-Nothing means an explicit user-written forall+ -- e.g. data T a = forall b. MkT b (b->a)+ -- con_qvars = {b} - , con_cxt :: Maybe (LHsContext name)+ , con_cxt :: Maybe (LHsContext pass) -- ^ User-written context (if any) - , con_details :: HsConDeclDetails name+ , con_details :: HsConDeclDetails pass -- ^ Arguments , con_doc :: Maybe LHsDocString -- ^ A possible Haddock comment. }-deriving instance (DataId name) => Data (ConDecl name)+deriving instance (DataId pass) => Data (ConDecl pass) -- | Haskell data Constructor Declaration Details-type HsConDeclDetails name- = HsConDetails (LBangType name) (Located [LConDeclField name])+type HsConDeclDetails pass+ = HsConDetails (LBangType pass) (Located [LConDeclField pass]) -getConNames :: ConDecl name -> [Located name]+getConNames :: ConDecl pass -> [Located (IdP pass)] getConNames ConDeclH98 {con_name = name} = [name] getConNames ConDeclGADT {con_names = names} = names -- don't call with RdrNames, because it can't deal with HsAppsTy-getConDetails :: ConDecl name -> HsConDeclDetails name+getConDetails :: ConDecl pass -> HsConDeclDetails pass getConDetails ConDeclH98 {con_details = details} = details getConDetails ConDeclGADT {con_type = ty } = details where (details,_,_,_) = gadtDeclDetails ty -- don't call with RdrNames, because it can't deal with HsAppsTy-gadtDeclDetails :: LHsSigType name- -> ( HsConDeclDetails name- , LHsType name- , LHsContext name- , [LHsTyVarBndr name] )+gadtDeclDetails :: LHsSigType pass+ -> ( HsConDeclDetails pass+ , LHsType pass+ , LHsContext pass+ , [LHsTyVarBndr pass] ) gadtDeclDetails HsIB {hsib_body = lbody_ty} = (details,res_ty,cxt,tvs) where (tvs, cxt, tau) = splitLHsSigmaTy lbody_ty@@ -1189,14 +1208,14 @@ -> (RecCon (L l flds), res_ty') _other -> (PrefixCon [], tau) -hsConDeclArgTys :: HsConDeclDetails name -> [LBangType name]+hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass] hsConDeclArgTys (PrefixCon tys) = tys hsConDeclArgTys (InfixCon ty1 ty2) = [ty1,ty2] hsConDeclArgTys (RecCon flds) = map (cd_fld_type . unLoc) (unLoc flds) -pp_data_defn :: (OutputableBndrId name)- => (HsContext name -> SDoc) -- Printing the header- -> HsDataDefn name+pp_data_defn :: (SourceTextX pass, OutputableBndrId pass)+ => (HsContext pass -> SDoc) -- Printing the header+ -> HsDataDefn pass -> SDoc pp_data_defn pp_hdr (HsDataDefn { dd_ND = new_or_data, dd_ctxt = L _ context , dd_cType = mb_ct@@ -1218,23 +1237,26 @@ Just kind -> dcolon <+> ppr kind pp_derivings (L _ ds) = vcat (map ppr ds) -instance (OutputableBndrId name) => Outputable (HsDataDefn name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsDataDefn pass) where ppr d = pp_data_defn (\_ -> text "Naked HsDataDefn") d instance Outputable NewOrData where ppr NewType = text "newtype" ppr DataType = text "data" -pp_condecls :: (OutputableBndrId name) => [LConDecl name] -> SDoc+pp_condecls :: (SourceTextX pass, OutputableBndrId pass)+ => [LConDecl pass] -> SDoc pp_condecls cs@(L _ ConDeclGADT{} : _) -- In GADT syntax = hang (text "where") 2 (vcat (map ppr cs)) pp_condecls cs -- In H98 syntax = equals <+> sep (punctuate (text " |") (map ppr cs)) -instance (OutputableBndrId name) => Outputable (ConDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (ConDecl pass) where ppr = pprConDecl -pprConDecl :: (OutputableBndrId name) => ConDecl name -> SDoc+pprConDecl :: (SourceTextX pass, OutputableBndrId pass) => ConDecl pass -> SDoc pprConDecl (ConDeclH98 { con_name = L _ con , con_qvars = mtvs , con_cxt = mcxt@@ -1244,7 +1266,7 @@ where ppr_details (InfixCon t1 t2) = hsep [ppr t1, pprInfixOcc con, ppr t2] ppr_details (PrefixCon tys) = hsep (pprPrefixOcc con- : map (pprParendHsType . unLoc) tys)+ : map (pprHsType . unLoc) tys) ppr_details (RecCon fields) = pprPrefixOcc con <+> pprConDeclFields (unLoc fields) tvs = case mtvs of@@ -1257,7 +1279,7 @@ = sep [ppr_mbDoc doc <+> ppr_con_names cons <+> dcolon <+> ppr res_ty] -ppr_con_names :: (OutputableBndr name) => [Located name] -> SDoc+ppr_con_names :: (OutputableBndr a) => [Located a] -> SDoc ppr_con_names = pprWithCommas (pprPrefixOcc . unLoc) {-@@ -1269,46 +1291,52 @@ Note [Type family instance declarations in HsSyn] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The data type TyFamEqn represents one equation of a type family instance.-It is parameterised over its tfe_pats field:+The data type FamEqn represents one equation of a type family instance.+Aside from the pass, it is also parameterised over two fields:+feqn_pats and feqn_rhs. +feqn_pats is either LHsTypes (for ordinary data/type family instances) or+LHsQTyVars (for associated type family default instances). In particular:+ * An ordinary type family instance declaration looks like this in source Haskell type instance T [a] Int = a -> a (or something similar for a closed family)- It is represented by a TyFamInstEqn, with *type* in the tfe_pats field.+ It is represented by a FamInstEqn, with a *type* (LHsType) in the feqn_pats+ field. * On the other hand, the *default instance* of an associated type looks like this in source Haskell class C a where type T a b type T a b = a -> b -- The default instance- It is represented by a TyFamDefltEqn, with *type variables* in the tfe_pats- field.+ It is represented by a TyFamDefltEqn, with *type variables* (LHsQTyVars) in+ the feqn_pats field.++feqn_rhs is either an HsDataDefn (for data family instances) or an LHsType+(for type family instances). -} ----------------- Type synonym family instances ------------- -- | Located Type Family Instance Equation-type LTyFamInstEqn name = Located (TyFamInstEqn name)+type LTyFamInstEqn pass = Located (TyFamInstEqn pass) -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' -- when in a list -- For details on above see note [Api annotations] in ApiAnnotation -- | Located Type Family Default Equation-type LTyFamDefltEqn name = Located (TyFamDefltEqn name)+type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass) -- | Haskell Type Patterns-type HsTyPats name = HsImplicitBndrs name [LHsType name]- -- ^ Type patterns (with kind and type bndrs)- -- See Note [Family instance declaration binders]+type HsTyPats pass = [LHsType pass] {- Note [Family instance declaration binders] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The HsTyPats field is LHS patterns or a type/data family instance.--The hsib_vars of the HsImplicitBndrs are the template variables of the-type patterns, i.e. fv(pat_tys). Note in particular+For ordinary data/type family instances, the feqn_pats field of FamEqn stores+the LHS type (and kind) patterns. These type patterns can of course contain+type (and kind) variables, which are bound in the hsib_vars field of the+HsImplicitBndrs in FamInstEqn. Note in particular * The hsib_vars *includes* any anonymous wildcards. For example type instance F a _ = a@@ -1316,7 +1344,7 @@ '_' gets its own unique. In this context wildcards behave just like an ordinary type variable, only anonymous. -* The hsib_vars *including* type variables that are already in scope+* The hsib_vars *includes* type variables that are already in scope Eg class C s t where type F t p :: *@@ -1330,59 +1358,39 @@ type F (a8,b9) x10 = x10->a8 so that we can compare the type pattern in the 'instance' decl and in the associated 'type' decl++For associated type family default instances (TyFamDefltEqn), instead of using+type patterns with binders in a surrounding HsImplicitBndrs, we use raw type+variables (LHsQTyVars) in the feqn_pats field of FamEqn. -} -- | Type Family Instance Equation-type TyFamInstEqn name = TyFamEqn name (HsTyPats name)+type TyFamInstEqn pass = FamInstEqn pass (LHsType pass) -- | Type Family Default Equation-type TyFamDefltEqn name = TyFamEqn name (LHsQTyVars name)+type TyFamDefltEqn pass = FamEqn pass (LHsQTyVars pass) (LHsType pass) -- See Note [Type family instance declarations in HsSyn] --- | Type Family Equation------ One equation in a type family instance declaration--- See Note [Type family instance declarations in HsSyn]-data TyFamEqn name pats- = TyFamEqn- { tfe_tycon :: Located name- , tfe_pats :: pats- , tfe_fixity :: LexicalFixity -- ^ Fixity used in the declaration- , tfe_rhs :: LHsType name }- -- ^- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnEqual'-- -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name, Data pats) => Data (TyFamEqn name pats)- -- | Located Type Family Instance Declaration-type LTyFamInstDecl name = Located (TyFamInstDecl name)+type LTyFamInstDecl pass = Located (TyFamInstDecl pass) -- | Type Family Instance Declaration-data TyFamInstDecl name- = TyFamInstDecl- { tfid_eqn :: LTyFamInstEqn name- , tfid_fvs :: PostRn name NameSet }+newtype TyFamInstDecl pass = TyFamInstDecl { tfid_eqn :: TyFamInstEqn pass } -- ^ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType', -- 'ApiAnnotation.AnnInstance', -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (TyFamInstDecl name)+deriving instance DataId pass => Data (TyFamInstDecl pass) ----------------- Data family instances ------------- -- | Located Data Family Instance Declaration-type LDataFamInstDecl name = Located (DataFamInstDecl name)+type LDataFamInstDecl pass = Located (DataFamInstDecl pass) -- | Data Family Instance Declaration-data DataFamInstDecl name- = DataFamInstDecl- { dfid_tycon :: Located name- , dfid_pats :: HsTyPats name -- LHS- , dfid_fixity :: LexicalFixity -- ^ Fixity used in the declaration- , dfid_defn :: HsDataDefn name -- RHS- , dfid_fvs :: PostRn name NameSet } -- Free vars for dependency analysis+newtype DataFamInstDecl pass+ = DataFamInstDecl { dfid_eqn :: FamInstEqn pass (HsDataDefn pass) } -- ^ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnData', -- 'ApiAnnotation.AnnNewType','ApiAnnotation.AnnInstance',@@ -1391,24 +1399,54 @@ -- 'ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (DataFamInstDecl name)+deriving instance DataId pass => Data (DataFamInstDecl pass) +----------------- Family instances (common types) ------------- +-- | Located Family Instance Equation+type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs)++-- | Family Instance Equation+type FamInstEqn pass rhs+ = HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs)+ -- ^ Here, the @pats@ are type patterns (with kind and type bndrs).+ -- See Note [Family instance declaration binders]++-- | Family Equation+--+-- One equation in a type family instance declaration, data family instance+-- declaration, or type family default.+-- See Note [Type family instance declarations in HsSyn]+-- See Note [Family instance declaration binders]+data FamEqn pass pats rhs+ = FamEqn+ { feqn_tycon :: Located (IdP pass)+ , feqn_pats :: pats+ , feqn_fixity :: LexicalFixity -- ^ Fixity used in the declaration+ , feqn_rhs :: rhs+ }+ -- ^+ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnEqual'++ -- For details on above see note [Api annotations] in ApiAnnotation+deriving instance (DataId pass, Data pats, Data rhs)+ => Data (FamEqn pass pats rhs)+ ----------------- Class instances ------------- -- | Located Class Instance Declaration-type LClsInstDecl name = Located (ClsInstDecl name)+type LClsInstDecl pass = Located (ClsInstDecl pass) -- | Class Instance Declaration-data ClsInstDecl name+data ClsInstDecl pass = ClsInstDecl- { cid_poly_ty :: LHsSigType name -- Context => Class Instance-type+ { cid_poly_ty :: LHsSigType pass -- Context => Class Instance-type -- Using a polytype means that the renamer conveniently -- figures out the quantified type variables for us.- , cid_binds :: LHsBinds name -- Class methods- , cid_sigs :: [LSig name] -- User-supplied pragmatic info- , cid_tyfam_insts :: [LTyFamInstDecl name] -- Type family instances- , cid_datafam_insts :: [LDataFamInstDecl name] -- Data family instances+ , cid_binds :: LHsBinds pass -- Class methods+ , cid_sigs :: [LSig pass] -- User-supplied pragmatic info+ , cid_tyfam_insts :: [LTyFamInstDecl pass] -- Type family instances+ , cid_datafam_insts :: [LDataFamInstDecl pass] -- Data family instances , cid_overlap_mode :: Maybe (Located OverlapMode) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnClose',@@ -1427,23 +1465,24 @@ ----------------- Instances of all kinds ------------- -- | Located Instance Declaration-type LInstDecl name = Located (InstDecl name)+type LInstDecl pass = Located (InstDecl pass) -- | Instance Declaration-data InstDecl name -- Both class and family instances+data InstDecl pass -- Both class and family instances = ClsInstD- { cid_inst :: ClsInstDecl name }+ { cid_inst :: ClsInstDecl pass } | DataFamInstD -- data family instance- { dfid_inst :: DataFamInstDecl name }+ { dfid_inst :: DataFamInstDecl pass } | TyFamInstD -- type family instance- { tfid_inst :: TyFamInstDecl name }+ { tfid_inst :: TyFamInstDecl pass } deriving instance (DataId id) => Data (InstDecl id) -instance (OutputableBndrId name) => Outputable (TyFamInstDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (TyFamInstDecl pass) where ppr = pprTyFamInstDecl TopLevel -pprTyFamInstDecl :: (OutputableBndrId name)- => TopLevelFlag -> TyFamInstDecl name -> SDoc+pprTyFamInstDecl :: (SourceTextX pass, OutputableBndrId pass)+ => TopLevelFlag -> TyFamInstDecl pass -> SDoc pprTyFamInstDecl top_lvl (TyFamInstDecl { tfid_eqn = eqn }) = text "type" <+> ppr_instance_keyword top_lvl <+> ppr_fam_inst_eqn eqn @@ -1451,57 +1490,71 @@ ppr_instance_keyword TopLevel = text "instance" ppr_instance_keyword NotTopLevel = empty -ppr_fam_inst_eqn :: (OutputableBndrId name) => LTyFamInstEqn name -> SDoc-ppr_fam_inst_eqn (L _ (TyFamEqn { tfe_tycon = tycon- , tfe_pats = pats- , tfe_fixity = fixity- , tfe_rhs = rhs }))- = pp_fam_inst_lhs tycon pats fixity [] <+> equals <+> ppr rhs+ppr_fam_inst_eqn :: (SourceTextX pass, OutputableBndrId pass)+ => TyFamInstEqn pass -> SDoc+ppr_fam_inst_eqn (HsIB { hsib_body = FamEqn { feqn_tycon = tycon+ , feqn_pats = pats+ , feqn_fixity = fixity+ , feqn_rhs = rhs }})+ = pprFamInstLHS tycon pats fixity [] Nothing <+> equals <+> ppr rhs -ppr_fam_deflt_eqn :: (OutputableBndrId name) => LTyFamDefltEqn name -> SDoc-ppr_fam_deflt_eqn (L _ (TyFamEqn { tfe_tycon = tycon- , tfe_pats = tvs- , tfe_fixity = fixity- , tfe_rhs = rhs }))+ppr_fam_deflt_eqn :: (SourceTextX pass, OutputableBndrId pass)+ => LTyFamDefltEqn pass -> SDoc+ppr_fam_deflt_eqn (L _ (FamEqn { feqn_tycon = tycon+ , feqn_pats = tvs+ , feqn_fixity = fixity+ , feqn_rhs = rhs })) = text "type" <+> pp_vanilla_decl_head tycon tvs fixity [] <+> equals <+> ppr rhs -instance (OutputableBndrId name) => Outputable (DataFamInstDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (DataFamInstDecl pass) where ppr = pprDataFamInstDecl TopLevel -pprDataFamInstDecl :: (OutputableBndrId name)- => TopLevelFlag -> DataFamInstDecl name -> SDoc-pprDataFamInstDecl top_lvl (DataFamInstDecl { dfid_tycon = tycon- , dfid_pats = pats- , dfid_fixity = fixity- , dfid_defn = defn })+pprDataFamInstDecl :: (SourceTextX pass, OutputableBndrId pass)+ => TopLevelFlag -> DataFamInstDecl pass -> SDoc+pprDataFamInstDecl top_lvl (DataFamInstDecl { dfid_eqn = HsIB { hsib_body =+ FamEqn { feqn_tycon = tycon+ , feqn_pats = pats+ , feqn_fixity = fixity+ , feqn_rhs = defn }}}) = pp_data_defn pp_hdr defn where pp_hdr ctxt = ppr_instance_keyword top_lvl- <+> pp_fam_inst_lhs tycon pats fixity ctxt+ <+> pprFamInstLHS tycon pats fixity ctxt (dd_kindSig defn) -pprDataFamInstFlavour :: DataFamInstDecl name -> SDoc-pprDataFamInstFlavour (DataFamInstDecl { dfid_defn = (HsDataDefn { dd_ND = nd }) })+pprDataFamInstFlavour :: DataFamInstDecl pass -> SDoc+pprDataFamInstFlavour (DataFamInstDecl { dfid_eqn = HsIB { hsib_body =+ FamEqn { feqn_rhs = HsDataDefn { dd_ND = nd }}}}) = ppr nd -pp_fam_inst_lhs :: (OutputableBndrId name) => Located name- -> HsTyPats name+pprFamInstLHS :: (SourceTextX pass, OutputableBndrId pass)+ => Located (IdP pass)+ -> HsTyPats pass -> LexicalFixity- -> HsContext name+ -> HsContext pass+ -> Maybe (LHsKind pass) -> SDoc-pp_fam_inst_lhs thing (HsIB { hsib_body = typats }) fixity context+pprFamInstLHS thing typats fixity context mb_kind_sig -- explicit type patterns- = hsep [ pprHsContext context, pp_pats typats]+ = hsep [ pprHsContext context, pp_pats typats, pp_kind_sig ] where pp_pats (patl:patsr) | fixity == Infix- = hsep [pprParendHsType (unLoc patl), pprInfixOcc (unLoc thing)- , hsep (map (pprParendHsType.unLoc) patsr)]+ = hsep [pprHsType (unLoc patl), pprInfixOcc (unLoc thing)+ , hsep (map (pprHsType.unLoc) patsr)] | otherwise = hsep [ pprPrefixOcc (unLoc thing)- , hsep (map (pprParendHsType.unLoc) (patl:patsr))]- pp_pats [] = empty+ , hsep (map (pprHsType.unLoc) (patl:patsr))]+ pp_pats [] = pprPrefixOcc (unLoc thing) -instance (OutputableBndrId name) => Outputable (ClsInstDecl name) where+ pp_kind_sig+ | Just k <- mb_kind_sig+ = dcolon <+> ppr k+ | otherwise+ = empty++instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (ClsInstDecl pass) where ppr (ClsInstDecl { cid_poly_ty = inst_ty, cid_binds = binds , cid_sigs = sigs, cid_tyfam_insts = ats , cid_overlap_mode = mbOverlap@@ -1539,14 +1592,15 @@ maybe_stext (SourceText src) _ = text src <+> text "#-}" -instance (OutputableBndrId name) => Outputable (InstDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (InstDecl pass) where ppr (ClsInstD { cid_inst = decl }) = ppr decl ppr (TyFamInstD { tfid_inst = decl }) = ppr decl ppr (DataFamInstD { dfid_inst = decl }) = ppr decl -- Extract the declarations of associated data types from an instance -instDeclDataFamInsts :: [LInstDecl name] -> [DataFamInstDecl name]+instDeclDataFamInsts :: [LInstDecl pass] -> [DataFamInstDecl pass] instDeclDataFamInsts inst_decls = concatMap do_one inst_decls where@@ -1564,11 +1618,11 @@ -} -- | Located Deriving Declaration-type LDerivDecl name = Located (DerivDecl name)+type LDerivDecl pass = Located (DerivDecl pass) -- | Deriving Declaration-data DerivDecl name = DerivDecl- { deriv_type :: LHsSigType name+data DerivDecl pass = DerivDecl+ { deriv_type :: LHsSigType pass , deriv_strategy :: Maybe (Located DerivStrategy) , deriv_overlap_mode :: Maybe (Located OverlapMode) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDeriving',@@ -1578,9 +1632,10 @@ -- For details on above see note [Api annotations] in ApiAnnotation }-deriving instance (DataId name) => Data (DerivDecl name)+deriving instance (DataId pass) => Data (DerivDecl pass) -instance (OutputableBndrId name) => Outputable (DerivDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (DerivDecl pass) where ppr (DerivDecl { deriv_type = ty , deriv_strategy = ds , deriv_overlap_mode = o })@@ -1603,18 +1658,19 @@ -} -- | Located Default Declaration-type LDefaultDecl name = Located (DefaultDecl name)+type LDefaultDecl pass = Located (DefaultDecl pass) -- | Default Declaration-data DefaultDecl name- = DefaultDecl [LHsType name]+data DefaultDecl pass+ = DefaultDecl [LHsType pass] -- ^ - 'ApiAnnotation.AnnKeywordId's : 'ApiAnnotation.AnnDefault', -- 'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (DefaultDecl name)+deriving instance (DataId pass) => Data (DefaultDecl pass) -instance (OutputableBndrId name) => Outputable (DefaultDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (DefaultDecl pass) where ppr (DefaultDecl tys) = text "default" <+> parens (interpp'SP tys)@@ -1634,20 +1690,20 @@ -- has been used -- | Located Foreign Declaration-type LForeignDecl name = Located (ForeignDecl name)+type LForeignDecl pass = Located (ForeignDecl pass) -- | Foreign Declaration-data ForeignDecl name+data ForeignDecl pass = ForeignImport- { fd_name :: Located name -- defines this name- , fd_sig_ty :: LHsSigType name -- sig_ty- , fd_co :: PostTc name Coercion -- rep_ty ~ sig_ty+ { fd_name :: Located (IdP pass) -- defines this name+ , fd_sig_ty :: LHsSigType pass -- sig_ty+ , fd_co :: PostTc pass Coercion -- rep_ty ~ sig_ty , fd_fi :: ForeignImport } | ForeignExport- { fd_name :: Located name -- uses this name- , fd_sig_ty :: LHsSigType name -- sig_ty- , fd_co :: PostTc name Coercion -- rep_ty ~ sig_ty+ { fd_name :: Located (IdP pass) -- uses this name+ , fd_sig_ty :: LHsSigType pass -- sig_ty+ , fd_co :: PostTc pass Coercion -- rep_ty ~ sig_ty , fd_fe :: ForeignExport } -- ^ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnForeign',@@ -1656,7 +1712,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation -deriving instance (DataId name) => Data (ForeignDecl name)+deriving instance (DataId pass) => Data (ForeignDecl pass) {- In both ForeignImport and ForeignExport: sig_ty is the type given in the Haskell code@@ -1717,7 +1773,8 @@ -- pretty printing of foreign declarations -- -instance (OutputableBndrId name) => Outputable (ForeignDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (ForeignDecl pass) where ppr (ForeignImport { fd_name = n, fd_sig_ty = ty, fd_fi = fimport }) = hang (text "foreign import" <+> ppr fimport <+> ppr n) 2 (dcolon <+> ppr ty)@@ -1766,29 +1823,29 @@ -} -- | Located Rule Declarations-type LRuleDecls name = Located (RuleDecls name)+type LRuleDecls pass = Located (RuleDecls pass) -- Note [Pragma source text] in BasicTypes -- | Rule Declarations-data RuleDecls name = HsRules { rds_src :: SourceText- , rds_rules :: [LRuleDecl name] }-deriving instance (DataId name) => Data (RuleDecls name)+data RuleDecls pass = HsRules { rds_src :: SourceText+ , rds_rules :: [LRuleDecl pass] }+deriving instance (DataId pass) => Data (RuleDecls pass) -- | Located Rule Declaration-type LRuleDecl name = Located (RuleDecl name)+type LRuleDecl pass = Located (RuleDecl pass) -- | Rule Declaration-data RuleDecl name+data RuleDecl pass = HsRule -- Source rule (Located (SourceText,RuleName)) -- Rule name -- Note [Pragma source text] in BasicTypes Activation- [LRuleBndr name] -- Forall'd vars; after typechecking this+ [LRuleBndr pass] -- Forall'd vars; after typechecking this -- includes tyvars- (Located (HsExpr name)) -- LHS- (PostRn name NameSet) -- Free-vars from the LHS- (Located (HsExpr name)) -- RHS- (PostRn name NameSet) -- Free-vars from the RHS+ (Located (HsExpr pass)) -- LHS+ (PostRn pass NameSet) -- Free-vars from the LHS+ (Located (HsExpr pass)) -- RHS+ (PostRn pass NameSet) -- Free-vars from the RHS -- ^ -- - 'ApiAnnotation.AnnKeywordId' : -- 'ApiAnnotation.AnnOpen','ApiAnnotation.AnnTilde',@@ -1798,37 +1855,39 @@ -- 'ApiAnnotation.AnnEqual', -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (RuleDecl name)+deriving instance (DataId pass) => Data (RuleDecl pass) -flattenRuleDecls :: [LRuleDecls name] -> [LRuleDecl name]+flattenRuleDecls :: [LRuleDecls pass] -> [LRuleDecl pass] flattenRuleDecls decls = concatMap (rds_rules . unLoc) decls -- | Located Rule Binder-type LRuleBndr name = Located (RuleBndr name)+type LRuleBndr pass = Located (RuleBndr pass) -- | Rule Binder-data RuleBndr name- = RuleBndr (Located name)- | RuleBndrSig (Located name) (LHsSigWcType name)+data RuleBndr pass+ = RuleBndr (Located (IdP pass))+ | RuleBndrSig (Located (IdP pass)) (LHsSigWcType pass) -- ^ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnDcolon','ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (RuleBndr name)+deriving instance (DataId pass) => Data (RuleBndr pass) -collectRuleBndrSigTys :: [RuleBndr name] -> [LHsSigWcType name]+collectRuleBndrSigTys :: [RuleBndr pass] -> [LHsSigWcType pass] collectRuleBndrSigTys bndrs = [ty | RuleBndrSig _ ty <- bndrs] pprFullRuleName :: Located (SourceText, RuleName) -> SDoc pprFullRuleName (L _ (st, n)) = pprWithSourceText st (doubleQuotes $ ftext n) -instance (OutputableBndrId name) => Outputable (RuleDecls name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (RuleDecls pass) where ppr (HsRules st rules) = pprWithSourceText st (text "{-# RULES") <+> vcat (punctuate semi (map ppr rules)) <+> text "#-}" -instance (OutputableBndrId name) => Outputable (RuleDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (RuleDecl pass) where ppr (HsRule name act ns lhs _fv_lhs rhs _fv_rhs) = sep [pprFullRuleName name <+> ppr act, nest 4 (pp_forall <+> pprExpr (unLoc lhs)),@@ -1837,7 +1896,8 @@ pp_forall | null ns = empty | otherwise = forAllLit <+> fsep (map ppr ns) <> dot -instance (OutputableBndrId name) => Outputable (RuleBndr name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (RuleBndr pass) where ppr (RuleBndr name) = ppr name ppr (RuleBndrSig name ty) = parens (ppr name <> dcolon <> ppr ty) @@ -1859,21 +1919,21 @@ -} -- | Located Vectorise Declaration-type LVectDecl name = Located (VectDecl name)+type LVectDecl pass = Located (VectDecl pass) -- | Vectorise Declaration-data VectDecl name+data VectDecl pass = HsVect SourceText -- Note [Pragma source text] in BasicTypes- (Located name)- (LHsExpr name)+ (Located (IdP pass))+ (LHsExpr pass) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnEqual','ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation | HsNoVect SourceText -- Note [Pragma source text] in BasicTypes- (Located name)+ (Located (IdP pass)) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnClose' @@ -1881,8 +1941,8 @@ | HsVectTypeIn -- pre type-checking SourceText -- Note [Pragma source text] in BasicTypes Bool -- 'TRUE' => SCALAR declaration- (Located name)- (Maybe (Located name)) -- 'Nothing' => no right-hand side+ (Located (IdP pass))+ (Maybe (Located (IdP pass))) -- 'Nothing' => no right-hand side -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnType','ApiAnnotation.AnnClose', -- 'ApiAnnotation.AnnEqual'@@ -1894,7 +1954,7 @@ (Maybe TyCon) -- 'Nothing' => no right-hand side | HsVectClassIn -- pre type-checking SourceText -- Note [Pragma source text] in BasicTypes- (Located name)+ (Located (IdP pass)) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnClass','ApiAnnotation.AnnClose', @@ -1902,12 +1962,12 @@ | HsVectClassOut -- post type-checking Class | HsVectInstIn -- pre type-checking (always SCALAR) !!!FIXME: should be superfluous now- (LHsSigType name)+ (LHsSigType pass) | HsVectInstOut -- post type-checking (always SCALAR) !!!FIXME: should be superfluous now ClsInst-deriving instance (DataId name) => Data (VectDecl name)+deriving instance (DataId pass) => Data (VectDecl pass) -lvectDeclName :: NamedThing name => LVectDecl name -> Name+lvectDeclName :: NamedThing (IdP pass) => LVectDecl pass -> Name lvectDeclName (L _ (HsVect _ (L _ name) _)) = getName name lvectDeclName (L _ (HsNoVect _ (L _ name))) = getName name lvectDeclName (L _ (HsVectTypeIn _ _ (L _ name) _)) = getName name@@ -1919,12 +1979,13 @@ lvectDeclName (L _ (HsVectInstOut _)) = panic "HsDecls.lvectDeclName: HsVectInstOut" -lvectInstDecl :: LVectDecl name -> Bool+lvectInstDecl :: LVectDecl pass -> Bool lvectInstDecl (L _ (HsVectInstIn _)) = True lvectInstDecl (L _ (HsVectInstOut _)) = True lvectInstDecl _ = False -instance (OutputableBndrId name) => Outputable (VectDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (VectDecl pass) where ppr (HsVect _ v rhs) = sep [text "{-# VECTORISE" <+> ppr v, nest 4 $@@ -1996,28 +2057,28 @@ -} -- | Located Warning Declarations-type LWarnDecls name = Located (WarnDecls name)+type LWarnDecls pass = Located (WarnDecls pass) -- Note [Pragma source text] in BasicTypes -- | Warning pragma Declarations-data WarnDecls name = Warnings { wd_src :: SourceText- , wd_warnings :: [LWarnDecl name]+data WarnDecls pass = Warnings { wd_src :: SourceText+ , wd_warnings :: [LWarnDecl pass] }- deriving Data+deriving instance (DataId pass) => Data (WarnDecls pass) -- | Located Warning pragma Declaration-type LWarnDecl name = Located (WarnDecl name)+type LWarnDecl pass = Located (WarnDecl pass) -- | Warning pragma Declaration-data WarnDecl name = Warning [Located name] WarningTxt- deriving Data+data WarnDecl pass = Warning [Located (IdP pass)] WarningTxt+deriving instance (DataId pass) => Data (WarnDecl pass) -instance OutputableBndr name => Outputable (WarnDecls name) where+instance OutputableBndr (IdP pass) => Outputable (WarnDecls pass) where ppr (Warnings (SourceText src) decls) = text src <+> vcat (punctuate comma (map ppr decls)) <+> text "#-}" ppr (Warnings NoSourceText _decls) = panic "WarnDecls" -instance OutputableBndr name => Outputable (WarnDecl name) where+instance OutputableBndr (IdP pass) => Outputable (WarnDecl pass) where ppr (Warning thing txt) = hsep ( punctuate comma (map ppr thing)) <+> ppr txt@@ -2031,21 +2092,22 @@ -} -- | Located Annotation Declaration-type LAnnDecl name = Located (AnnDecl name)+type LAnnDecl pass = Located (AnnDecl pass) -- | Annotation Declaration-data AnnDecl name = HsAnnotation+data AnnDecl pass = HsAnnotation SourceText -- Note [Pragma source text] in BasicTypes- (AnnProvenance name) (Located (HsExpr name))+ (AnnProvenance (IdP pass)) (Located (HsExpr pass)) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnType' -- 'ApiAnnotation.AnnModule' -- 'ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (AnnDecl name)+deriving instance (DataId pass) => Data (AnnDecl pass) -instance (OutputableBndrId name) => Outputable (AnnDecl name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (AnnDecl pass) where ppr (HsAnnotation _ provenance expr) = hsep [text "{-#", pprAnnProvenance provenance, pprExpr (unLoc expr), text "#-}"] @@ -2053,9 +2115,10 @@ data AnnProvenance name = ValueAnnProvenance (Located name) | TypeAnnProvenance (Located name) | ModuleAnnProvenance- deriving (Data, Functor)+deriving instance Functor AnnProvenance deriving instance Foldable AnnProvenance deriving instance Traversable AnnProvenance+deriving instance (Data pass) => Data (AnnProvenance pass) annProvenanceName_maybe :: AnnProvenance name -> Maybe name annProvenanceName_maybe (ValueAnnProvenance (L _ name)) = Just name@@ -2078,21 +2141,21 @@ -} -- | Located Role Annotation Declaration-type LRoleAnnotDecl name = Located (RoleAnnotDecl name)+type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass) -- See #8185 for more info about why role annotations are -- top-level declarations -- | Role Annotation Declaration-data RoleAnnotDecl name- = RoleAnnotDecl (Located name) -- type constructor+data RoleAnnotDecl pass+ = RoleAnnotDecl (Located (IdP pass)) -- type constructor [Located (Maybe Role)] -- optional annotations -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType', -- 'ApiAnnotation.AnnRole' -- For details on above see note [Api annotations] in ApiAnnotation- deriving Data+deriving instance (DataId pass) => Data (RoleAnnotDecl pass) -instance OutputableBndr name => Outputable (RoleAnnotDecl name) where+instance OutputableBndr (IdP pass) => Outputable (RoleAnnotDecl pass) where ppr (RoleAnnotDecl ltycon roles) = text "type role" <+> ppr ltycon <+> hsep (map (pp_role . unLoc) roles)@@ -2100,5 +2163,5 @@ pp_role Nothing = underscore pp_role (Just r) = ppr r -roleAnnotDeclName :: RoleAnnotDecl name -> name+roleAnnotDeclName :: RoleAnnotDecl pass -> (IdP pass) roleAnnotDeclName (RoleAnnotDecl (L _ name) _) = name
hsSyn/HsDoc.hs view
@@ -8,6 +8,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Outputable import SrcLoc import FastString
hsSyn/HsDumpAst.hs view
@@ -15,22 +15,21 @@ BlankSrcSpan(..), ) where +import GhcPrelude+ import Data.Data hiding (Fixity)-import Data.List import Bag import BasicTypes import FastString import NameSet import Name-import RdrName import DataCon import SrcLoc import HsSyn import OccName hiding (occName) import Var import Module-import DynFlags-import Outputable hiding (space)+import Outputable import qualified Data.ByteString as B @@ -40,117 +39,132 @@ -- | Show a GHC syntax tree. This parameterised because it is also used for -- comparing ASTs in ppr roundtripping tests, where the SrcSpan's are blanked -- out, to avoid comparing locations, only structure-showAstData :: Data a => BlankSrcSpan -> a -> String-showAstData b = showAstData' 0+showAstData :: Data a => BlankSrcSpan -> a -> SDoc+showAstData b a0 = blankLine $$ showAstData' a0 where- showAstData' :: Data a => Int -> a -> String- showAstData' n =+ showAstData' :: Data a => a -> SDoc+ showAstData' = generic `ext1Q` list- `extQ` string `extQ` fastString `extQ` srcSpan `extQ` lit+ `extQ` string `extQ` fastString `extQ` srcSpan+ `extQ` lit `extQ` litr `extQ` litt `extQ` bytestring `extQ` name `extQ` occName `extQ` moduleName `extQ` var `extQ` dataCon `extQ` bagName `extQ` bagRdrName `extQ` bagVar `extQ` nameSet `extQ` fixity `ext2Q` located- where generic :: Data a => a -> String- generic t = indent n ++ "(" ++ showConstr (toConstr t)- ++ space (unwords (gmapQ (showAstData' (n+1)) t)) ++ ")" - space "" = ""- space s = ' ':s-- indent i = "\n" ++ replicate i ' '+ where generic :: Data a => a -> SDoc+ generic t = parens $ text (showConstr (toConstr t))+ $$ vcat (gmapQ showAstData' t) - string :: String -> String- string = normalize_newlines . show+ string :: String -> SDoc+ string = text . normalize_newlines . show - fastString :: FastString -> String- fastString = ("{FastString: "++) . (++"}") . normalize_newlines- . show+ fastString :: FastString -> SDoc+ fastString s = braces $+ text "FastString: "+ <> text (normalize_newlines . show $ s) - bytestring :: B.ByteString -> String- bytestring = normalize_newlines . show+ bytestring :: B.ByteString -> SDoc+ bytestring = text . normalize_newlines . show - list l = indent n ++ "["- ++ intercalate "," (map (showAstData' (n+1)) l)- ++ "]"+ list [] = brackets empty+ list [x] = brackets (showAstData' x)+ list (x1 : x2 : xs) = (text "[" <> showAstData' x1)+ $$ go x2 xs+ where+ go y [] = text "," <> showAstData' y <> text "]"+ go y1 (y2 : ys) = (text "," <> showAstData' y1) $$ go y2 ys -- Eliminate word-size dependence- lit :: HsLit -> String+ lit :: HsLit GhcPs -> SDoc lit (HsWordPrim s x) = numericLit "HsWord{64}Prim" x s lit (HsWord64Prim s x) = numericLit "HsWord{64}Prim" x s lit (HsIntPrim s x) = numericLit "HsInt{64}Prim" x s lit (HsInt64Prim s x) = numericLit "HsInt{64}Prim" x s lit l = generic l - numericLit :: String -> Integer -> SourceText -> String- numericLit tag x s = indent n ++ unwords [ "{" ++ tag- , generic x- , generic s ++ "}" ]+ litr :: HsLit GhcRn -> SDoc+ litr (HsWordPrim s x) = numericLit "HsWord{64}Prim" x s+ litr (HsWord64Prim s x) = numericLit "HsWord{64}Prim" x s+ litr (HsIntPrim s x) = numericLit "HsInt{64}Prim" x s+ litr (HsInt64Prim s x) = numericLit "HsInt{64}Prim" x s+ litr l = generic l - name :: Name -> String- name = ("{Name: "++) . (++"}") . showSDocDebug_ . ppr+ litt :: HsLit GhcTc -> SDoc+ litt (HsWordPrim s x) = numericLit "HsWord{64}Prim" x s+ litt (HsWord64Prim s x) = numericLit "HsWord{64}Prim" x s+ litt (HsIntPrim s x) = numericLit "HsInt{64}Prim" x s+ litt (HsInt64Prim s x) = numericLit "HsInt{64}Prim" x s+ litt l = generic l - occName = ("{OccName: "++) . (++"}") . OccName.occNameString+ numericLit :: String -> Integer -> SourceText -> SDoc+ numericLit tag x s = braces $ hsep [ text tag+ , generic x+ , generic s ] - moduleName :: ModuleName -> String- moduleName = ("{ModuleName: "++) . (++"}") . showSDoc_ . ppr+ name :: Name -> SDoc+ name nm = braces $ text "Name: " <> ppr nm - srcSpan :: SrcSpan -> String+ occName n = braces $+ text "OccName: "+ <> text (OccName.occNameString n)++ moduleName :: ModuleName -> SDoc+ moduleName m = braces $ text "ModuleName: " <> ppr m++ srcSpan :: SrcSpan -> SDoc srcSpan ss = case b of- BlankSrcSpan -> "{ "++ "ss" ++"}"- NoBlankSrcSpan ->- "{ "++ showSDoc_ (hang (ppr ss) (n+2)- -- TODO: show annotations here- (text "")- )- ++"}"+ BlankSrcSpan -> text "{ ss }"+ NoBlankSrcSpan -> braces $ char ' ' <>+ (hang (ppr ss) 1+ -- TODO: show annotations here+ (text "")) - var :: Var -> String- var = ("{Var: "++) . (++"}") . showSDocDebug_ . ppr+ var :: Var -> SDoc+ var v = braces $ text "Var: " <> ppr v - dataCon :: DataCon -> String- dataCon = ("{DataCon: "++) . (++"}") . showSDoc_ . ppr+ dataCon :: DataCon -> SDoc+ dataCon c = braces $ text "DataCon: " <> ppr c - bagRdrName:: Bag (Located (HsBind RdrName)) -> String- bagRdrName = ("{Bag(Located (HsBind RdrName)): "++) . (++"}")- . list . bagToList+ bagRdrName:: Bag (Located (HsBind GhcPs)) -> SDoc+ bagRdrName bg = braces $+ text "Bag(Located (HsBind GhcPs)):"+ $$ (list . bagToList $ bg) - bagName :: Bag (Located (HsBind Name)) -> String- bagName = ("{Bag(Located (HsBind Name)): "++) . (++"}")- . list . bagToList+ bagName :: Bag (Located (HsBind GhcRn)) -> SDoc+ bagName bg = braces $+ text "Bag(Located (HsBind Name)):"+ $$ (list . bagToList $ bg) - bagVar :: Bag (Located (HsBind Var)) -> String- bagVar = ("{Bag(Located (HsBind Var)): "++) . (++"}")- . list . bagToList+ bagVar :: Bag (Located (HsBind GhcTc)) -> SDoc+ bagVar bg = braces $+ text "Bag(Located (HsBind Var)):"+ $$ (list . bagToList $ bg) - nameSet = ("{NameSet: "++) . (++"}") . list . nameSetElemsStable+ nameSet ns = braces $+ text "NameSet:"+ $$ (list . nameSetElemsStable $ ns) - fixity :: Fixity -> String- fixity = ("{Fixity: "++) . (++"}") . showSDoc_ . ppr+ fixity :: Fixity -> SDoc+ fixity fx = braces $+ text "Fixity: "+ <> ppr fx - located :: (Data b,Data loc) => GenLocated loc b -> String- located (L ss a) =- indent n ++ "("- ++ case cast ss of+ located :: (Data b,Data loc) => GenLocated loc b -> SDoc+ located (L ss a) = parens $+ case cast ss of Just (s :: SrcSpan) -> srcSpan s- Nothing -> "nnnnnnnn"- ++ showAstData' (n+1) a- ++ ")"+ Nothing -> text "nnnnnnnn"+ $$ showAstData' a normalize_newlines :: String -> String normalize_newlines ('\\':'r':'\\':'n':xs) = '\\':'n':normalize_newlines xs normalize_newlines (x:xs) = x:normalize_newlines xs normalize_newlines [] = []--showSDoc_ :: SDoc -> String-showSDoc_ = normalize_newlines . showSDoc unsafeGlobalDynFlags--showSDocDebug_ :: SDoc -> String-showSDocDebug_ = normalize_newlines . showSDocDebug unsafeGlobalDynFlags {- ************************************************************************
hsSyn/HsExpr.hs view
@@ -18,18 +18,19 @@ #include "HsVersions.h" -- friends:+import GhcPrelude+ import HsDecls import HsPat import HsLit-import PlaceHolder ( PostTc,PostRn,DataId,DataIdPost,- NameOrRdrName,OutputableBndrId )+import PlaceHolder ( NameOrRdrName )+import HsExtension import HsTypes import HsBinds -- others: import TcEvidence import CoreSyn-import Var import DynFlags ( gopt, GeneralFlag(Opt_PrintExplicitCoercions) ) import Name import NameSet@@ -61,7 +62,7 @@ -- * Expressions proper -- | Located Haskell Expression-type LHsExpr id = Located (HsExpr id)+type LHsExpr p = Located (HsExpr p) -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when -- in a list @@ -72,7 +73,7 @@ -- -- PostTcExpr is an evidence expression attached to the syntax tree by the -- type checker (c.f. postTcType).-type PostTcExpr = HsExpr Id+type PostTcExpr = HsExpr GhcTc -- | Post-Type checking Table --@@ -81,7 +82,7 @@ type PostTcTable = [(Name, PostTcExpr)] noPostTcExpr :: PostTcExpr-noPostTcExpr = HsLit (HsString NoSourceText (fsLit "noPostTcExpr"))+noPostTcExpr = HsLit (HsString noSourceText (fsLit "noPostTcExpr")) noPostTcTable :: PostTcTable noPostTcTable = []@@ -105,33 +106,34 @@ -- This could be defined using @PostRn@ and @PostTc@ and such, but it's -- harder to get it all to work out that way. ('noSyntaxExpr' is hard to -- write, for example.)-data SyntaxExpr id = SyntaxExpr { syn_expr :: HsExpr id- , syn_arg_wraps :: [HsWrapper]- , syn_res_wrap :: HsWrapper }-deriving instance (DataId id) => Data (SyntaxExpr id)+data SyntaxExpr p = SyntaxExpr { syn_expr :: HsExpr p+ , syn_arg_wraps :: [HsWrapper]+ , syn_res_wrap :: HsWrapper }+deriving instance (DataId p) => Data (SyntaxExpr p) -- | This is used for rebindable-syntax pieces that are too polymorphic -- for tcSyntaxOp (trS_fmap and the mzip in ParStmt)-noExpr :: HsExpr id-noExpr = HsLit (HsString (SourceText "noExpr") (fsLit "noExpr"))+noExpr :: SourceTextX p => HsExpr p+noExpr = HsLit (HsString (sourceText "noExpr") (fsLit "noExpr")) -noSyntaxExpr :: SyntaxExpr id -- Before renaming, and sometimes after,+noSyntaxExpr :: SourceTextX p => SyntaxExpr p+ -- Before renaming, and sometimes after, -- (if the syntax slot makes no sense)-noSyntaxExpr = SyntaxExpr { syn_expr = HsLit (HsString NoSourceText+noSyntaxExpr = SyntaxExpr { syn_expr = HsLit (HsString noSourceText (fsLit "noSyntaxExpr")) , syn_arg_wraps = [] , syn_res_wrap = WpHole } -- | Make a 'SyntaxExpr Name' (the "rn" is because this is used in the -- renamer), missing its HsWrappers.-mkRnSyntaxExpr :: Name -> SyntaxExpr Name+mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn mkRnSyntaxExpr name = SyntaxExpr { syn_expr = HsVar $ noLoc name , syn_arg_wraps = [] , syn_res_wrap = WpHole } -- don't care about filling in syn_arg_wraps because we're clearly -- not past the typechecker -instance (OutputableBndrId id) => Outputable (SyntaxExpr id) where+instance (SourceTextX p, OutputableBndrId p) => Outputable (SyntaxExpr p) where ppr (SyntaxExpr { syn_expr = expr , syn_arg_wraps = arg_wraps , syn_res_wrap = res_wrap })@@ -143,7 +145,7 @@ else ppr expr -- | Command Syntax Table (for Arrow syntax)-type CmdSyntaxTable id = [(Name, HsExpr id)]+type CmdSyntaxTable p = [(Name, HsExpr p)] -- See Note [CmdSyntaxTable] {-@@ -196,7 +198,8 @@ deriving Data instance Outputable UnboundVar where- ppr = ppr . unboundVarOcc+ ppr (OutOfScope occ _) = text "OutOfScope" <> parens (ppr occ)+ ppr (TrueExprHole occ) = text "ExprHole" <> parens (ppr occ) unboundVarOcc :: UnboundVar -> OccName unboundVarOcc (OutOfScope occ _) = occ@@ -273,8 +276,8 @@ -} -- | A Haskell expression.-data HsExpr id- = HsVar (Located id) -- ^ Variable+data HsExpr p+ = HsVar (Located (IdP p)) -- ^ Variable -- See Note [Located RdrNames] @@ -289,28 +292,29 @@ | HsConLikeOut ConLike -- ^ After typechecker only; must be different -- HsVar for pretty printing - | HsRecFld (AmbiguousFieldOcc id) -- ^ Variable pointing to record selector+ | HsRecFld (AmbiguousFieldOcc p) -- ^ Variable pointing to record selector -- Not in use after typechecking - | HsOverLabel (Maybe id) FastString+ | HsOverLabel (Maybe (IdP p)) FastString -- ^ Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels) -- @Just id@ means @RebindableSyntax@ is in use, and gives the id of the -- in-scope 'fromLabel'. -- NB: Not in use after typechecking | HsIPVar HsIPName -- ^ Implicit parameter (not in use after typechecking)- | HsOverLit (HsOverLit id) -- ^ Overloaded literals+ | HsOverLit (HsOverLit p) -- ^ Overloaded literals - | HsLit HsLit -- ^ Simple (non-overloaded) literals+ | HsLit (HsLit p) -- ^ Simple (non-overloaded) literals - | HsLam (MatchGroup id (LHsExpr id)) -- ^ Lambda abstraction. Currently always a single match+ | HsLam (MatchGroup p (LHsExpr p))+ -- ^ Lambda abstraction. Currently always a single match -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam', -- 'ApiAnnotation.AnnRarrow', -- For details on above see note [Api annotations] in ApiAnnotation - | HsLamCase (MatchGroup id (LHsExpr id)) -- ^ Lambda-case+ | HsLamCase (MatchGroup p (LHsExpr p)) -- ^ Lambda-case -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam', -- 'ApiAnnotation.AnnCase','ApiAnnotation.AnnOpen',@@ -318,16 +322,17 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsApp (LHsExpr id) (LHsExpr id) -- ^ Application+ | HsApp (LHsExpr p) (LHsExpr p) -- ^ Application - | HsAppType (LHsExpr id) (LHsWcType id) -- ^ Visible type application+ | HsAppType (LHsExpr p) (LHsWcType p) -- ^ Visible type application -- -- Explicit type argument; e.g f @Int x y -- NB: Has wildcards, but no implicit quantification -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnAt', - | HsAppTypeOut (LHsExpr id) (LHsWcType Name) -- just for pretty-printing+ -- TODO:AZ: Sort out Name+ | HsAppTypeOut (LHsExpr p) (LHsWcType GhcRn) -- just for pretty-printing -- | Operator applications:@@ -336,10 +341,10 @@ -- NB We need an expr for the operator in an OpApp/Section since -- the typechecker may need to apply the operator to a few types. - | OpApp (LHsExpr id) -- left operand- (LHsExpr id) -- operator- (PostRn id Fixity) -- Renamer adds fixity; bottom until then- (LHsExpr id) -- right operand+ | OpApp (LHsExpr p) -- left operand+ (LHsExpr p) -- operator+ (PostRn p Fixity) -- Renamer adds fixity; bottom until then+ (LHsExpr p) -- right operand -- | Negation operator. Contains the negated expression and the name -- of 'negate'@@ -347,19 +352,19 @@ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnMinus' -- For details on above see note [Api annotations] in ApiAnnotation- | NegApp (LHsExpr id)- (SyntaxExpr id)+ | NegApp (LHsExpr p)+ (SyntaxExpr p) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@, -- 'ApiAnnotation.AnnClose' @')'@ -- For details on above see note [Api annotations] in ApiAnnotation- | HsPar (LHsExpr id) -- ^ Parenthesised expr; see Note [Parens in HsSyn]+ | HsPar (LHsExpr p) -- ^ Parenthesised expr; see Note [Parens in HsSyn] - | SectionL (LHsExpr id) -- operand; see Note [Sections in HsSyn]- (LHsExpr id) -- operator- | SectionR (LHsExpr id) -- operator; see Note [Sections in HsSyn]- (LHsExpr id) -- operand+ | SectionL (LHsExpr p) -- operand; see Note [Sections in HsSyn]+ (LHsExpr p) -- operator+ | SectionR (LHsExpr p) -- operator; see Note [Sections in HsSyn]+ (LHsExpr p) -- operand -- | Used for explicit tuples and sections thereof --@@ -368,7 +373,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation | ExplicitTuple- [LHsTupArg id]+ [LHsTupArg p] Boxity -- | Used for unboxed sum types@@ -381,16 +386,16 @@ | ExplicitSum ConTag -- Alternative (one-based) Arity -- Sum arity- (LHsExpr id)- (PostTc id [Type]) -- the type arguments+ (LHsExpr p)+ (PostTc p [Type]) -- the type arguments -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnCase', -- 'ApiAnnotation.AnnOf','ApiAnnotation.AnnOpen' @'{'@, -- 'ApiAnnotation.AnnClose' @'}'@ -- For details on above see note [Api annotations] in ApiAnnotation- | HsCase (LHsExpr id)- (MatchGroup id (LHsExpr id))+ | HsCase (LHsExpr p)+ (MatchGroup p (LHsExpr p)) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnIf', -- 'ApiAnnotation.AnnSemi',@@ -398,12 +403,12 @@ -- 'ApiAnnotation.AnnElse', -- For details on above see note [Api annotations] in ApiAnnotation- | HsIf (Maybe (SyntaxExpr id)) -- cond function+ | HsIf (Maybe (SyntaxExpr p)) -- cond function -- Nothing => use the built-in 'if' -- See Note [Rebindable if]- (LHsExpr id) -- predicate- (LHsExpr id) -- then part- (LHsExpr id) -- else part+ (LHsExpr p) -- predicate+ (LHsExpr p) -- then part+ (LHsExpr p) -- else part -- | Multi-way if --@@ -411,7 +416,7 @@ -- 'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose', -- For details on above see note [Api annotations] in ApiAnnotation- | HsMultiIf (PostTc id Type) [LGRHS id (LHsExpr id)]+ | HsMultiIf (PostTc p Type) [LGRHS p (LHsExpr p)] -- | let(rec) --@@ -420,8 +425,8 @@ -- 'ApiAnnotation.AnnClose' @'}'@,'ApiAnnotation.AnnIn' -- For details on above see note [Api annotations] in ApiAnnotation- | HsLet (LHsLocalBinds id)- (LHsExpr id)+ | HsLet (LHsLocalBinds p)+ (LHsExpr p) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDo', -- 'ApiAnnotation.AnnOpen', 'ApiAnnotation.AnnSemi',@@ -432,8 +437,8 @@ | HsDo (HsStmtContext Name) -- The parameterisation is unimportant -- because in this context we never use -- the PatGuard or ParStmt variant- (Located [ExprLStmt id]) -- "do":one or more stmts- (PostTc id Type) -- Type of the whole expression+ (Located [ExprLStmt p]) -- "do":one or more stmts+ (PostTc p Type) -- Type of the whole expression -- | Syntactic list: [a,b,c,...] --@@ -442,9 +447,10 @@ -- For details on above see note [Api annotations] in ApiAnnotation | ExplicitList- (PostTc id Type) -- Gives type of components of list- (Maybe (SyntaxExpr id)) -- For OverloadedLists, the fromListN witness- [LHsExpr id]+ (PostTc p Type) -- Gives type of components of list+ (Maybe (SyntaxExpr p))+ -- For OverloadedLists, the fromListN witness+ [LHsExpr p] -- | Syntactic parallel array: [:e1, ..., en:] --@@ -455,8 +461,8 @@ -- For details on above see note [Api annotations] in ApiAnnotation | ExplicitPArr- (PostTc id Type) -- type of elements of the parallel array- [LHsExpr id]+ (PostTc p Type) -- type of elements of the parallel array+ [LHsExpr p] -- | Record construction --@@ -465,11 +471,12 @@ -- For details on above see note [Api annotations] in ApiAnnotation | RecordCon- { rcon_con_name :: Located id -- The constructor name;+ { rcon_con_name :: Located (IdP p) -- The constructor name; -- not used after type checking- , rcon_con_like :: PostTc id ConLike -- The data constructor or pattern synonym+ , rcon_con_like :: PostTc p ConLike+ -- The data constructor or pattern synonym , rcon_con_expr :: PostTcExpr -- Instantiated constructor function- , rcon_flds :: HsRecordBinds id } -- The fields+ , rcon_flds :: HsRecordBinds p } -- The fields -- | Record update --@@ -478,18 +485,18 @@ -- For details on above see note [Api annotations] in ApiAnnotation | RecordUpd- { rupd_expr :: LHsExpr id- , rupd_flds :: [LHsRecUpdField id]- , rupd_cons :: PostTc id [ConLike]+ { rupd_expr :: LHsExpr p+ , rupd_flds :: [LHsRecUpdField p]+ , rupd_cons :: PostTc p [ConLike] -- Filled in by the type checker to the -- _non-empty_ list of DataCons that have -- all the upd'd fields - , rupd_in_tys :: PostTc id [Type] -- Argument types of *input* record type- , rupd_out_tys :: PostTc id [Type] -- and *output* record type- -- The original type can be reconstructed- -- with conLikeResTy- , rupd_wrap :: PostTc id HsWrapper -- See note [Record Update HsWrapper]+ , rupd_in_tys :: PostTc p [Type] -- Argument types of *input* record type+ , rupd_out_tys :: PostTc p [Type] -- and *output* record type+ -- The original type can be reconstructed+ -- with conLikeResTy+ , rupd_wrap :: PostTc p HsWrapper -- See note [Record Update HsWrapper] } -- For a type family, the arg types are of the *instance* tycon, -- not the family tycon@@ -500,12 +507,12 @@ -- For details on above see note [Api annotations] in ApiAnnotation | ExprWithTySig- (LHsExpr id)- (LHsSigWcType id)+ (LHsExpr p)+ (LHsSigWcType p) | ExprWithTySigOut -- Post typechecking- (LHsExpr id)- (LHsSigWcType Name) -- Retain the signature,+ (LHsExpr p)+ (LHsSigWcType GhcRn) -- Retain the signature, -- as HsSigType Name, for -- round-tripping purposes @@ -518,8 +525,9 @@ -- For details on above see note [Api annotations] in ApiAnnotation | ArithSeq PostTcExpr- (Maybe (SyntaxExpr id)) -- For OverloadedLists, the fromList witness- (ArithSeqInfo id)+ (Maybe (SyntaxExpr p))+ -- For OverloadedLists, the fromList witness+ (ArithSeqInfo p) -- | Arithmetic sequence for parallel array --@@ -533,7 +541,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation | PArrSeq PostTcExpr- (ArithSeqInfo id)+ (ArithSeqInfo p) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{-\# SCC'@, -- 'ApiAnnotation.AnnVal' or 'ApiAnnotation.AnnValStr',@@ -542,7 +550,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation | HsSCC SourceText -- Note [Pragma source text] in BasicTypes StringLiteral -- "set cost centre" SCC pragma- (LHsExpr id) -- expr whose cost is to be measured+ (LHsExpr p) -- expr whose cost is to be measured -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{-\# CORE'@, -- 'ApiAnnotation.AnnVal', 'ApiAnnotation.AnnClose' @'\#-}'@@@ -550,7 +558,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation | HsCoreAnn SourceText -- Note [Pragma source text] in BasicTypes StringLiteral -- hdaume: core annotation- (LHsExpr id)+ (LHsExpr p) ----------------------------------------------------------- -- MetaHaskell Extensions@@ -560,16 +568,16 @@ -- 'ApiAnnotation.AnnClose','ApiAnnotation.AnnCloseQ' -- For details on above see note [Api annotations] in ApiAnnotation- | HsBracket (HsBracket id)+ | HsBracket (HsBracket p) -- See Note [Pending Splices] | HsRnBracketOut- (HsBracket Name) -- Output of the renamer is the *original* renamed+ (HsBracket GhcRn) -- Output of the renamer is the *original* renamed -- expression, plus [PendingRnSplice] -- _renamed_ splices to be type checked | HsTcBracketOut- (HsBracket Name) -- Output of the type checker is the *original*+ (HsBracket GhcRn) -- Output of the type checker is the *original* -- renamed expression, plus [PendingTcSplice] -- _typechecked_ splices to be -- pasted back in by the desugarer@@ -578,7 +586,7 @@ -- 'ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation- | HsSpliceE (HsSplice id)+ | HsSpliceE (HsSplice p) ----------------------------------------------------------- -- Arrow notation extension@@ -589,17 +597,17 @@ -- 'ApiAnnotation.AnnRarrow' -- For details on above see note [Api annotations] in ApiAnnotation- | HsProc (LPat id) -- arrow abstraction, proc- (LHsCmdTop id) -- body of the abstraction- -- always has an empty stack+ | HsProc (LPat p) -- arrow abstraction, proc+ (LHsCmdTop p) -- body of the abstraction+ -- always has an empty stack --------------------------------------- -- static pointers extension -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnStatic', -- For details on above see note [Api annotations] in ApiAnnotation- | HsStatic (PostRn id NameSet) -- Free variables of the body- (LHsExpr id) -- Body+ | HsStatic (PostRn p NameSet) -- Free variables of the body+ (LHsExpr p) -- Body --------------------------------------- -- The following are commands, not expressions proper@@ -612,37 +620,37 @@ -- For details on above see note [Api annotations] in ApiAnnotation | HsArrApp -- Arrow tail, or arrow application (f -< arg)- (LHsExpr id) -- arrow expression, f- (LHsExpr id) -- input expression, arg- (PostTc id Type) -- type of the arrow expressions f,- -- of the form a t t', where arg :: t- HsArrAppType -- higher-order (-<<) or first-order (-<)- Bool -- True => right-to-left (f -< arg)- -- False => left-to-right (arg >- f)+ (LHsExpr p) -- arrow expression, f+ (LHsExpr p) -- input expression, arg+ (PostTc p Type) -- type of the arrow expressions f,+ -- of the form a t t', where arg :: t+ HsArrAppType -- higher-order (-<<) or first-order (-<)+ Bool -- True => right-to-left (f -< arg)+ -- False => left-to-right (arg >- f) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpenB' @'(|'@, -- 'ApiAnnotation.AnnCloseB' @'|)'@ -- For details on above see note [Api annotations] in ApiAnnotation | HsArrForm -- Command formation, (| e cmd1 .. cmdn |)- (LHsExpr id) -- the operator+ (LHsExpr p) -- the operator -- after type-checking, a type abstraction to be -- applied to the type of the local environment tuple (Maybe Fixity) -- fixity (filled in by the renamer), for forms that -- were converted from OpApp's by the renamer- [LHsCmdTop id] -- argument commands+ [LHsCmdTop p] -- argument commands --------------------------------------- -- Haskell program coverage (Hpc) Support | HsTick- (Tickish id)- (LHsExpr id) -- sub-expression+ (Tickish (IdP p))+ (LHsExpr p) -- sub-expression | HsBinTick Int -- module-local tick number for True Int -- module-local tick number for False- (LHsExpr id) -- sub-expression+ (LHsExpr p) -- sub-expression -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnOpen' @'{-\# GENERATED'@,@@ -661,7 +669,7 @@ ((SourceText,SourceText),(SourceText,SourceText)) -- Source text for the four integers used in the span. -- See note [Pragma source text] in BasicTypes- (LHsExpr id)+ (LHsExpr p) --------------------------------------- -- These constructors only appear temporarily in the parser.@@ -672,28 +680,31 @@ -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnAt' -- For details on above see note [Api annotations] in ApiAnnotation- | EAsPat (Located id) -- as pattern- (LHsExpr id)+ | EAsPat (Located (IdP p)) -- as pattern+ (LHsExpr p) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow' -- For details on above see note [Api annotations] in ApiAnnotation- | EViewPat (LHsExpr id) -- view pattern- (LHsExpr id)+ | EViewPat (LHsExpr p) -- view pattern+ (LHsExpr p) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnTilde' -- For details on above see note [Api annotations] in ApiAnnotation- | ELazyPat (LHsExpr id) -- ~ pattern+ | ELazyPat (LHsExpr p) -- ~ pattern --------------------------------------- -- Finally, HsWrap appears only in typechecker output+ -- The contained Expr is *NOT* itself an HsWrap.+ -- See Note [Detecting forced eta expansion] in DsExpr. This invariant+ -- is maintained by HsUtils.mkHsWrap. | HsWrap HsWrapper -- TRANSLATION- (HsExpr id)+ (HsExpr p) -deriving instance (DataId id) => Data (HsExpr id)+deriving instance (DataId p) => Data (HsExpr p) -- | Located Haskell Tuple Argument --@@ -732,7 +743,7 @@ https://phabricator.haskell.org/rGHC499e43824bda967546ebf95ee33ec1f84a114a7c * ParPat and HsParTy are pretty printed as '( .. )' regardless of whether or- not they are strictly necssary. This should be addressed when #13238 is+ not they are strictly necessary. This should be addressed when #13238 is completed, to be treated the same as HsPar. @@ -788,16 +799,16 @@ RenamedSource, so this allows a simple mapping to be used based on the location. -} -instance (OutputableBndrId id) => Outputable (HsExpr id) where+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsExpr p) where ppr expr = pprExpr expr ----------------------- -- pprExpr, pprLExpr, pprBinds call pprDeeper; -- the underscore versions do not-pprLExpr :: (OutputableBndrId id) => LHsExpr id -> SDoc+pprLExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc pprLExpr (L _ e) = pprExpr e -pprExpr :: (OutputableBndrId id) => HsExpr id -> SDoc+pprExpr :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc pprExpr e | isAtomicHsExpr e || isQuietHsExpr e = ppr_expr e | otherwise = pprDeeper (ppr_expr e) @@ -813,15 +824,16 @@ isQuietHsExpr (OpApp _ _ _ _) = True isQuietHsExpr _ = False -pprBinds :: (OutputableBndrId idL, OutputableBndrId idR)+pprBinds :: (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR idL idR -> SDoc pprBinds b = pprDeeper (ppr b) ------------------------ppr_lexpr :: (OutputableBndrId id) => LHsExpr id -> SDoc+ppr_lexpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc ppr_lexpr e = ppr_expr (unLoc e) -ppr_expr :: forall id. (OutputableBndrId id) => HsExpr id -> SDoc+ppr_expr :: forall p. (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc ppr_expr (HsVar (L _ v)) = pprPrefixOcc v ppr_expr (HsUnboundVar uv)= pprPrefixOcc (unboundVarOcc uv) ppr_expr (HsConLikeOut c) = pprPrefixOcc c@@ -871,6 +883,8 @@ = case unLoc op of HsVar (L _ v) -> pp_infixly v HsConLikeOut c -> pp_infixly (conLikeName c)+ HsUnboundVar h@TrueExprHole{}+ -> pp_infixly (unboundVarOcc h) _ -> pp_prefixly where pp_expr = pprDebugParendExpr expr@@ -883,6 +897,8 @@ = case unLoc op of HsVar (L _ v) -> pp_infixly v HsConLikeOut c -> pp_infixly (conLikeName c)+ HsUnboundVar h@TrueExprHole{}+ -> pp_infixly (unboundVarOcc h) _ -> pp_prefixly where pp_expr = pprDebugParendExpr expr@@ -1039,10 +1055,11 @@ -- We must tiresomely make the "id" parameter to the LHsWcType existential -- because it's different in the HsAppType case and the HsAppTypeOut case -- | Located Haskell Wildcard Type Expression-data LHsWcTypeX = forall id. (OutputableBndrId id) => LHsWcTypeX (LHsWcType id)+data LHsWcTypeX = forall p. (SourceTextX p, OutputableBndrId p)+ => LHsWcTypeX (LHsWcType p) -ppr_apps :: (OutputableBndrId id) => HsExpr id- -> [Either (LHsExpr id) LHsWcTypeX]+ppr_apps :: (SourceTextX p, OutputableBndrId p) => HsExpr p+ -> [Either (LHsExpr p) LHsWcTypeX] -> SDoc ppr_apps (HsApp (L _ fun) arg) args = ppr_apps fun (Left arg : args)@@ -1054,7 +1071,7 @@ where pp (Left arg) = ppr arg pp (Right (LHsWcTypeX (HsWC { hswc_body = L _ arg })))- = char '@' <> pprParendHsType arg+ = char '@' <> pprHsType arg pprExternalSrcLoc :: (StringLiteral,(Int,Int),(Int,Int)) -> SDoc pprExternalSrcLoc (StringLiteral _ src,(n1,n2),(n3,n4))@@ -1072,16 +1089,16 @@ can see the structure of the parse tree. -} -pprDebugParendExpr :: (OutputableBndrId id) => LHsExpr id -> SDoc+pprDebugParendExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc pprDebugParendExpr expr = getPprStyle (\sty -> if debugStyle sty then pprParendLExpr expr else pprLExpr expr) -pprParendLExpr :: (OutputableBndrId id) => LHsExpr id -> SDoc+pprParendLExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc pprParendLExpr (L _ e) = pprParendExpr e -pprParendExpr :: (OutputableBndrId id) => HsExpr id -> SDoc+pprParendExpr :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc pprParendExpr expr | hsExprNeedsParens expr = parens (pprExpr expr) | otherwise = pprExpr expr@@ -1242,26 +1259,26 @@ -} -- | Located Haskell Top-level Command-type LHsCmdTop id = Located (HsCmdTop id)+type LHsCmdTop p = Located (HsCmdTop p) -- | Haskell Top-level Command-data HsCmdTop id- = HsCmdTop (LHsCmd id)- (PostTc id Type) -- Nested tuple of inputs on the command's stack- (PostTc id Type) -- return type of the command- (CmdSyntaxTable id) -- See Note [CmdSyntaxTable]-deriving instance (DataId id) => Data (HsCmdTop id)+data HsCmdTop p+ = HsCmdTop (LHsCmd p)+ (PostTc p Type) -- Nested tuple of inputs on the command's stack+ (PostTc p Type) -- return type of the command+ (CmdSyntaxTable p) -- See Note [CmdSyntaxTable]+deriving instance (DataId p) => Data (HsCmdTop p) -instance (OutputableBndrId id) => Outputable (HsCmd id) where+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsCmd p) where ppr cmd = pprCmd cmd ----------------------- -- pprCmd and pprLCmd call pprDeeper; -- the underscore versions do not-pprLCmd :: (OutputableBndrId id) => LHsCmd id -> SDoc+pprLCmd :: (SourceTextX p, OutputableBndrId p) => LHsCmd p -> SDoc pprLCmd (L _ c) = pprCmd c -pprCmd :: (OutputableBndrId id) => HsCmd id -> SDoc+pprCmd :: (SourceTextX p, OutputableBndrId p) => HsCmd p -> SDoc pprCmd c | isQuietHsCmd c = ppr_cmd c | otherwise = pprDeeper (ppr_cmd c) @@ -1275,10 +1292,10 @@ isQuietHsCmd _ = False ------------------------ppr_lcmd :: (OutputableBndrId id) => LHsCmd id -> SDoc+ppr_lcmd :: (SourceTextX p, OutputableBndrId p) => LHsCmd p -> SDoc ppr_lcmd c = ppr_cmd (unLoc c) -ppr_cmd :: forall id. (OutputableBndrId id) => HsCmd id -> SDoc+ppr_cmd :: forall p. (SourceTextX p, OutputableBndrId p) => HsCmd p -> SDoc ppr_cmd (HsCmdPar c) = parens (ppr_lcmd c) ppr_cmd (HsCmdApp c e)@@ -1339,11 +1356,11 @@ = hang (text "(|" <> ppr_lexpr op) 4 (sep (map (pprCmdArg.unLoc) args) <> text "|)") -pprCmdArg :: (OutputableBndrId id) => HsCmdTop id -> SDoc+pprCmdArg :: (SourceTextX p, OutputableBndrId p) => HsCmdTop p -> SDoc pprCmdArg (HsCmdTop cmd _ _ _) = ppr_lcmd cmd -instance (OutputableBndrId id) => Outputable (HsCmdTop id) where+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsCmdTop p) where ppr = pprCmdArg {-@@ -1355,7 +1372,7 @@ -} -- | Haskell Record Bindings-type HsRecordBinds id = HsRecFields id (LHsExpr id)+type HsRecordBinds p = HsRecFields p (LHsExpr p) {- ************************************************************************@@ -1379,15 +1396,15 @@ patterns in each equation. -} -data MatchGroup id body- = MG { mg_alts :: Located [LMatch id body] -- The alternatives- , mg_arg_tys :: [PostTc id Type] -- Types of the arguments, t1..tn- , mg_res_ty :: PostTc id Type -- Type of the result, tr+data MatchGroup p body+ = MG { mg_alts :: Located [LMatch p body] -- The alternatives+ , mg_arg_tys :: [PostTc p Type] -- Types of the arguments, t1..tn+ , mg_res_ty :: PostTc p Type -- Type of the result, tr , mg_origin :: Origin } -- The type is the type of the entire group -- t1 -> ... -> tn -> tr -- where there are n patterns-deriving instance (Data body,DataId id) => Data (MatchGroup id body)+deriving instance (Data body,DataId p) => Data (MatchGroup p body) -- | Located Match type LMatch id body = Located (Match id body)@@ -1395,20 +1412,16 @@ -- list -- For details on above see note [Api annotations] in ApiAnnotation-data Match id body+data Match p body = Match {- m_ctxt :: HsMatchContext (NameOrRdrName id),+ m_ctxt :: HsMatchContext (NameOrRdrName (IdP p)), -- See note [m_ctxt in Match]- m_pats :: [LPat id], -- The patterns- m_type :: (Maybe (LHsType id)),- -- A type signature for the result of the match- -- Nothing after typechecking- -- NB: No longer supported- m_grhss :: (GRHSs id body)+ m_pats :: [LPat p], -- The patterns+ m_grhss :: (GRHSs p body) }-deriving instance (Data body,DataId id) => Data (Match id body)+deriving instance (Data body,DataId p) => Data (Match p body) -instance (OutputableBndrId idR, Outputable body)+instance (SourceTextX idR, OutputableBndrId idR, Outputable body) => Outputable (Match idR body) where ppr = pprMatch @@ -1474,7 +1487,7 @@ | otherwise = panic "matchGroupArity" hsLMatchPats :: LMatch id body -> [LPat id]-hsLMatchPats (L _ (Match _ pats _ _)) = pats+hsLMatchPats (L _ (Match { m_pats = pats })) = pats -- | Guarded Right-Hand Sides --@@ -1486,12 +1499,12 @@ -- 'ApiAnnotation.AnnRarrow','ApiAnnotation.AnnSemi' -- For details on above see note [Api annotations] in ApiAnnotation-data GRHSs id body+data GRHSs p body = GRHSs {- grhssGRHSs :: [LGRHS id body], -- ^ Guarded RHSs- grhssLocalBinds :: LHsLocalBinds id -- ^ The where clause+ grhssGRHSs :: [LGRHS p body], -- ^ Guarded RHSs+ grhssLocalBinds :: LHsLocalBinds p -- ^ The where clause }-deriving instance (Data body,DataId id) => Data (GRHSs id body)+deriving instance (Data body,DataId p) => Data (GRHSs p body) -- | Located Guarded Right-Hand Side type LGRHS id body = Located (GRHS id body)@@ -1503,29 +1516,30 @@ -- We know the list must have at least one @Match@ in it. -pprMatches :: (OutputableBndrId idR, Outputable body)+pprMatches :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc pprMatches MG { mg_alts = matches } = vcat (map pprMatch (map unLoc (unLoc matches))) -- Don't print the type; it's only a place-holder before typechecking -- Exported to HsBinds, which can't see the defn of HsMatchContext-pprFunBind :: (OutputableBndrId idR, Outputable body)+pprFunBind :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc pprFunBind matches = pprMatches matches -- Exported to HsBinds, which can't see the defn of HsMatchContext-pprPatBind :: forall bndr id body. (OutputableBndrId bndr,- OutputableBndrId id,- Outputable body)- => LPat bndr -> GRHSs id body -> SDoc+pprPatBind :: forall bndr p body. (SourceTextX p, SourceTextX bndr,+ OutputableBndrId bndr,+ OutputableBndrId p,+ Outputable body)+ => LPat bndr -> GRHSs p body -> SDoc pprPatBind pat (grhss)- = sep [ppr pat, nest 2 (pprGRHSs (PatBindRhs :: HsMatchContext id) grhss)]+ = sep [ppr pat, nest 2 (pprGRHSs (PatBindRhs :: HsMatchContext (IdP p)) grhss)] -pprMatch :: (OutputableBndrId idR, Outputable body) => Match idR body -> SDoc+pprMatch :: (SourceTextX idR, OutputableBndrId idR, Outputable body)+ => Match idR body -> SDoc pprMatch match = sep [ sep (herald : map (nest 2 . pprParendLPat) other_pats)- , nest 2 ppr_maybe_ty , nest 2 (pprGRHSs ctxt (m_grhss match)) ] where ctxt = m_ctxt match@@ -1555,12 +1569,8 @@ (pat1:pats1) = m_pats match (pat2:pats2) = pats1- ppr_maybe_ty = case m_type match of- Just ty -> dcolon <+> ppr ty- Nothing -> empty --pprGRHSs :: (OutputableBndrId idR, Outputable body)+pprGRHSs :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHSs idR body -> SDoc pprGRHSs ctxt (GRHSs grhss (L _ binds)) = vcat (map (pprGRHS ctxt . unLoc) grhss)@@ -1569,7 +1579,7 @@ $$ ppUnless (eqEmptyLocalBinds binds) (text "where" $$ nest 4 (pprBinds binds)) -pprGRHS :: (OutputableBndrId idR, Outputable body)+pprGRHS :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHS idR body -> SDoc pprGRHS ctxt (GRHS [] body) = pp_rhs ctxt body@@ -1615,7 +1625,7 @@ -- | Guard Statement type GuardStmt id = Stmt id (LHsExpr id) --- | Ghci Located Statemnt+-- | Ghci Located Statement type GhciLStmt id = LStmt id (LHsExpr id) -- | Ghci Statement@@ -1695,7 +1705,7 @@ trS_stmts :: [ExprLStmt idL], -- Stmts to the *left* of the 'group' -- which generates the tuples to be grouped - trS_bndrs :: [(idR, idR)], -- See Note [TransStmt binder map]+ trS_bndrs :: [(IdP idR, IdP idR)], -- See Note [TransStmt binder map] trS_using :: LHsExpr idR, trS_by :: Maybe (LHsExpr idR), -- "by e" (optional)@@ -1719,12 +1729,14 @@ { recS_stmts :: [LStmtLR idL idR body] -- The next two fields are only valid after renaming- , recS_later_ids :: [idR] -- The ids are a subset of the variables bound by the- -- stmts that are used in stmts that follow the RecStmt+ , recS_later_ids :: [IdP idR]+ -- The ids are a subset of the variables bound by the+ -- stmts that are used in stmts that follow the RecStmt - , recS_rec_ids :: [idR] -- Ditto, but these variables are the "recursive" ones,- -- that are used before they are bound in the stmts of- -- the RecStmt.+ , recS_rec_ids :: [IdP idR]+ -- Ditto, but these variables are the "recursive" ones,+ -- that are used before they are bound in the stmts of+ -- the RecStmt. -- An Id can be in both groups -- Both sets of Ids are (now) treated monomorphically -- See Note [How RecStmt works] for why they are separate@@ -1763,19 +1775,24 @@ data ParStmtBlock idL idR = ParStmtBlock [ExprLStmt idL]- [idR] -- The variables to be returned+ [IdP idR] -- The variables to be returned (SyntaxExpr idR) -- The return operator deriving instance (DataId idL, DataId idR) => Data (ParStmtBlock idL idR) -- | Applicative Argument data ApplicativeArg idL idR- = ApplicativeArgOne -- pat <- expr (pat must be irrefutable)- (LPat idL)+ = ApplicativeArgOne -- A single statement (BindStmt or BodyStmt)+ (LPat idL) -- WildPat if it was a BodyStmt (see below) (LHsExpr idL)- | ApplicativeArgMany -- do { stmts; return vars }- [ExprLStmt idL] -- stmts- (HsExpr idL) -- return (v1,..,vn), or just (v1,..,vn)- (LPat idL) -- (v1,...,vn)+ Bool -- True <=> was a BodyStmt+ -- False <=> was a BindStmt+ -- See Note [Applicative BodyStmt]++ | ApplicativeArgMany -- do { stmts; return vars }+ [ExprLStmt idL] -- stmts+ (HsExpr idL) -- return (v1,..,vn), or just (v1,..,vn)+ (LPat idL) -- (v1,...,vn)+ deriving instance (DataId idL, DataId idR) => Data (ApplicativeArg idL idR) {-@@ -1913,20 +1930,51 @@ In any other context than 'MonadComp', the fields for most of these 'SyntaxExpr's stay bottom.+++Note [Applicative BodyStmt]++(#12143) For the purposes of ApplicativeDo, we treat any BodyStmt+as if it was a BindStmt with a wildcard pattern. For example,++ do+ x <- A+ B+ return x++is transformed as if it were++ do+ x <- A+ _ <- B+ return x++so it transforms to++ (\(x,_) -> x) <$> A <*> B++But we have to remember when we treat a BodyStmt like a BindStmt,+because in error messages we want to emit the original syntax the user+wrote, not our internal representation. So ApplicativeArgOne has a+Bool flag that is True when the original statement was a BodyStmt, so+that we can pretty-print it correctly. -} -instance (OutputableBndrId idL) => Outputable (ParStmtBlock idL idR) where+instance (SourceTextX idL, OutputableBndrId idL)+ => Outputable (ParStmtBlock idL idR) where ppr (ParStmtBlock stmts _ _) = interpp'SP stmts -instance (OutputableBndrId idL, OutputableBndrId idR, Outputable body)+instance (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR, Outputable body) => Outputable (StmtLR idL idR body) where ppr stmt = pprStmt stmt -pprStmt :: forall idL idR body . (OutputableBndrId idL, OutputableBndrId idR,+pprStmt :: forall idL idR body . (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR, Outputable body) => (StmtLR idL idR body) -> SDoc pprStmt (LastStmt expr ret_stripped _)- = ifPprDebug (text "[last]") <+>+ = whenPprDebug (text "[last]") <+> (if ret_stripped then text "return" else empty) <+> ppr expr pprStmt (BindStmt pat expr _ _ _) = hsep [ppr pat, larrow, ppr expr]@@ -1941,7 +1989,7 @@ , recS_later_ids = later_ids }) = text "rec" <+> vcat [ ppr_do_stmts segment- , ifPprDebug (vcat [ text "rec_ids=" <> ppr rec_ids+ , whenPprDebug (vcat [ text "rec_ids=" <> ppr rec_ids , text "later_ids=" <> ppr later_ids])] pprStmt (ApplicativeStmt args mb_join _)@@ -1962,7 +2010,11 @@ flattenStmt (L _ (ApplicativeStmt args _ _)) = concatMap flattenArg args flattenStmt stmt = [ppr stmt] - flattenArg (_, ApplicativeArgOne pat expr) =+ flattenArg (_, ApplicativeArgOne pat expr isBody)+ | isBody = -- See Note [Applicative BodyStmt]+ [ppr (BodyStmt expr noSyntaxExpr noSyntaxExpr (panic "pprStmt")+ :: ExprStmt idL)]+ | otherwise = [ppr (BindStmt pat expr noSyntaxExpr noSyntaxExpr (panic "pprStmt") :: ExprStmt idL)] flattenArg (_, ApplicativeArgMany stmts _ _) =@@ -1976,7 +2028,11 @@ then ap_expr else text "join" <+> parens ap_expr - pp_arg (_, ApplicativeArgOne pat expr) =+ pp_arg (_, ApplicativeArgOne pat expr isBody)+ | isBody = -- See Note [Applicative BodyStmt]+ ppr (BodyStmt expr noSyntaxExpr noSyntaxExpr (panic "pprStmt")+ :: ExprStmt idL)+ | otherwise = ppr (BindStmt pat expr noSyntaxExpr noSyntaxExpr (panic "pprStmt") :: ExprStmt idL) pp_arg (_, ApplicativeArgMany stmts return pat) =@@ -1986,10 +2042,10 @@ (stmts ++ [noLoc (LastStmt (noLoc return) False noSyntaxExpr)])) (error "pprStmt")) -pprTransformStmt :: (OutputableBndrId id)- => [id] -> LHsExpr id -> Maybe (LHsExpr id) -> SDoc+pprTransformStmt :: (SourceTextX p, OutputableBndrId p)+ => [IdP p] -> LHsExpr p -> Maybe (LHsExpr p) -> SDoc pprTransformStmt bndrs using by- = sep [ text "then" <+> ifPprDebug (braces (ppr bndrs))+ = sep [ text "then" <+> whenPprDebug (braces (ppr bndrs)) , nest 2 (ppr using) , nest 2 (pprBy by)] @@ -2003,8 +2059,8 @@ pprBy Nothing = empty pprBy (Just e) = text "by" <+> ppr e -pprDo :: (OutputableBndrId id, Outputable body)- => HsStmtContext any -> [LStmt id body] -> SDoc+pprDo :: (SourceTextX p, OutputableBndrId p, Outputable body)+ => HsStmtContext any -> [LStmt p body] -> SDoc pprDo DoExpr stmts = text "do" <+> ppr_do_stmts stmts pprDo GhciStmtCtxt stmts = text "do" <+> ppr_do_stmts stmts pprDo ArrowExpr stmts = text "do" <+> ppr_do_stmts stmts@@ -2014,12 +2070,14 @@ pprDo MonadComp stmts = brackets $ pprComp stmts pprDo _ _ = panic "pprDo" -- PatGuard, ParStmtCxt -ppr_do_stmts :: (OutputableBndrId idL, OutputableBndrId idR, Outputable body)+ppr_do_stmts :: (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR, Outputable body) => [LStmtLR idL idR body] -> SDoc -- Print a bunch of do stmts ppr_do_stmts stmts = pprDeeperList vcat (map ppr stmts) -pprComp :: (OutputableBndrId id, Outputable body) => [LStmt id body] -> SDoc+pprComp :: (SourceTextX p, OutputableBndrId p, Outputable body)+ => [LStmt p body] -> SDoc pprComp quals -- Prints: body | qual1, ..., qualn | Just (initStmts, L _ (LastStmt body _ _)) <- snocView quals = if null initStmts@@ -2033,7 +2091,8 @@ | otherwise = pprPanic "pprComp" (pprQuals quals) -pprQuals :: (OutputableBndrId id, Outputable body) => [LStmt id body] -> SDoc+pprQuals :: (SourceTextX p, OutputableBndrId p, Outputable body)+ => [LStmt p body] -> SDoc -- Show list comprehension qualifiers separated by commas pprQuals quals = interpp'SP quals @@ -2049,17 +2108,17 @@ data HsSplice id = HsTypedSplice -- $$z or $$(f 4) SpliceDecoration -- Whether $$( ) variant found, for pretty printing- id -- A unique name to identify this splice point+ (IdP id) -- A unique name to identify this splice point (LHsExpr id) -- See Note [Pending Splices] | HsUntypedSplice -- $z or $(f 4) SpliceDecoration -- Whether $( ) variant found, for pretty printing- id -- A unique name to identify this splice point+ (IdP id) -- A unique name to identify this splice point (LHsExpr id) -- See Note [Pending Splices] | HsQuasiQuote -- See Note [Quasi-quote overview] in TcSplice- id -- Splice point- id -- Quoter+ (IdP id) -- Splice point+ (IdP id) -- Quoter SrcSpan -- The span of the enclosed string FastString -- The enclosed string @@ -2120,7 +2179,8 @@ -- | Pending Renamer Splice data PendingRnSplice- = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr Name)+ -- AZ:TODO: The hard-coded GhcRn feels wrong. How to force the PostRn?+ = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn) deriving Data data UntypedSpliceFlavour@@ -2132,7 +2192,8 @@ -- | Pending Type-checker Splice data PendingTcSplice- = PendingTcSplice SplicePointName (LHsExpr Id)+ -- AZ:TODO: The hard-coded GhcTc feels wrong. How to force the PostTc?+ = PendingTcSplice SplicePointName (LHsExpr GhcTc) deriving Data @@ -2200,29 +2261,30 @@ sense, although I hate to add another constructor to HsExpr. -} -instance (OutputableBndrId id) => Outputable (HsSplicedThing id) where+instance (SourceTextX p, OutputableBndrId p)+ => Outputable (HsSplicedThing p) where ppr (HsSplicedExpr e) = ppr_expr e ppr (HsSplicedTy t) = ppr t ppr (HsSplicedPat p) = ppr p -instance (OutputableBndrId id) => Outputable (HsSplice id) where+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsSplice p) where ppr s = pprSplice s -pprPendingSplice :: (OutputableBndrId id)- => SplicePointName -> LHsExpr id -> SDoc+pprPendingSplice :: (SourceTextX p, OutputableBndrId p)+ => SplicePointName -> LHsExpr p -> SDoc pprPendingSplice n e = angleBrackets (ppr n <> comma <+> ppr e) -pprSpliceDecl :: (OutputableBndrId id)- => HsSplice id -> SpliceExplicitFlag -> SDoc+pprSpliceDecl :: (SourceTextX p, OutputableBndrId p)+ => HsSplice p -> SpliceExplicitFlag -> SDoc pprSpliceDecl e@HsQuasiQuote{} _ = pprSplice e pprSpliceDecl e ExplicitSplice = text "$(" <> ppr_splice_decl e <> text ")" pprSpliceDecl e ImplicitSplice = ppr_splice_decl e -ppr_splice_decl :: (OutputableBndrId id) => HsSplice id -> SDoc+ppr_splice_decl :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SDoc ppr_splice_decl (HsUntypedSplice _ n e) = ppr_splice empty n e empty ppr_splice_decl e = pprSplice e -pprSplice :: (OutputableBndrId id) => HsSplice id -> SDoc+pprSplice :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SDoc pprSplice (HsTypedSplice HasParens n e) = ppr_splice (text "$$(") n e (text ")") pprSplice (HsTypedSplice HasDollar n e)@@ -2238,36 +2300,36 @@ pprSplice (HsQuasiQuote n q _ s) = ppr_quasi n q s pprSplice (HsSpliced _ thing) = ppr thing -ppr_quasi :: OutputableBndr id => id -> id -> FastString -> SDoc-ppr_quasi n quoter quote = ifPprDebug (brackets (ppr n)) <>+ppr_quasi :: OutputableBndr p => p -> p -> FastString -> SDoc+ppr_quasi n quoter quote = whenPprDebug (brackets (ppr n)) <> char '[' <> ppr quoter <> vbar <> ppr quote <> text "|]" -ppr_splice :: (OutputableBndrId id)- => SDoc -> id -> LHsExpr id -> SDoc -> SDoc+ppr_splice :: (SourceTextX p, OutputableBndrId p)+ => SDoc -> (IdP p) -> LHsExpr p -> SDoc -> SDoc ppr_splice herald n e trail- = herald <> ifPprDebug (brackets (ppr n)) <> ppr e <> trail+ = herald <> whenPprDebug (brackets (ppr n)) <> ppr e <> trail -- | Haskell Bracket-data HsBracket id = ExpBr (LHsExpr id) -- [| expr |]- | PatBr (LPat id) -- [p| pat |]- | DecBrL [LHsDecl id] -- [d| decls |]; result of parser- | DecBrG (HsGroup id) -- [d| decls |]; result of renamer- | TypBr (LHsType id) -- [t| type |]- | VarBr Bool id -- True: 'x, False: ''T- -- (The Bool flag is used only in pprHsBracket)- | TExpBr (LHsExpr id) -- [|| expr ||]-deriving instance (DataId id) => Data (HsBracket id)+data HsBracket p = ExpBr (LHsExpr p) -- [| expr |]+ | PatBr (LPat p) -- [p| pat |]+ | DecBrL [LHsDecl p] -- [d| decls |]; result of parser+ | DecBrG (HsGroup p) -- [d| decls |]; result of renamer+ | TypBr (LHsType p) -- [t| type |]+ | VarBr Bool (IdP p) -- True: 'x, False: ''T+ -- (The Bool flag is used only in pprHsBracket)+ | TExpBr (LHsExpr p) -- [|| expr ||]+deriving instance (DataId p) => Data (HsBracket p) isTypedBracket :: HsBracket id -> Bool isTypedBracket (TExpBr {}) = True isTypedBracket _ = False -instance (OutputableBndrId id) => Outputable (HsBracket id) where+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsBracket p) where ppr = pprHsBracket -pprHsBracket :: (OutputableBndrId id) => HsBracket id -> SDoc+pprHsBracket :: (SourceTextX p, OutputableBndrId p) => HsBracket p -> SDoc pprHsBracket (ExpBr e) = thBrackets empty (ppr e) pprHsBracket (PatBr p) = thBrackets (char 'p') (ppr p) pprHsBracket (DecBrG gp) = thBrackets (char 'd') (ppr gp)@@ -2312,8 +2374,8 @@ (LHsExpr id) deriving instance (DataId id) => Data (ArithSeqInfo id) -instance (OutputableBndrId id)- => Outputable (ArithSeqInfo id) where+instance (SourceTextX p, OutputableBndrId p)+ => Outputable (ArithSeqInfo p) where ppr (From e1) = hcat [ppr e1, pp_dotdot] ppr (FromThen e1 e2) = hcat [ppr e1, comma, space, ppr e2, pp_dotdot] ppr (FromTo e1 e3) = hcat [ppr e1, pp_dotdot, ppr e3]@@ -2336,11 +2398,10 @@ -- Context of a pattern match. This is more subtle than it would seem. See Note -- [Varieties of pattern matches]. data HsMatchContext id -- Not an extensible tag- = FunRhs { mc_fun :: Located id -- ^ function binder of @f@- , mc_fixity :: LexicalFixity -- ^ fixing of @f@- , mc_strictness :: SrcStrictness- -- ^ was the pattern banged? See- -- Note [Varieties of binding pattern matches]+ = FunRhs { mc_fun :: Located id -- ^ function binder of @f@+ , mc_fixity :: LexicalFixity -- ^ fixing of @f@+ , mc_strictness :: SrcStrictness -- ^ was @f@ banged?+ -- See Note [FunBind vs PatBind] } -- ^A pattern matching on an argument of a -- function binding@@ -2361,7 +2422,7 @@ | ThPatQuote -- ^A Template Haskell pattern quotation [p| (a,b) |] | PatSyn -- ^A pattern synonym declaration deriving Functor-deriving instance (DataIdPost id) => Data (HsMatchContext id)+deriving instance (Data id) => Data (HsMatchContext id) instance OutputableBndr id => Outputable (HsMatchContext id) where ppr m@(FunRhs{}) = text "FunRhs" <+> ppr (mc_fun m) <+> ppr (mc_fixity m)@@ -2382,7 +2443,8 @@ PatSyn -> True _ -> False --- | Haskell Statement Context+-- | Haskell Statement Context. It expects to be parameterised with one of+-- 'RdrName', 'Name' or 'Id' data HsStmtContext id = ListComp | MonadComp@@ -2397,7 +2459,7 @@ | ParStmtCtxt (HsStmtContext id) -- ^A branch of a parallel stmt | TransStmtCtxt (HsStmtContext id) -- ^A branch of a transform stmt deriving Functor-deriving instance (DataIdPost id) => Data (HsStmtContext id)+deriving instance (Data id) => Data (HsStmtContext id) isListCompExpr :: HsStmtContext id -> Bool -- Uses syntax [ e | quals ]@@ -2495,16 +2557,14 @@ -- transformed branch of -- transformed branch of monad comprehension pprStmtContext (ParStmtCtxt c) =- sdocWithPprDebug $ \dbg -> if dbg- then sep [text "parallel branch of", pprAStmtContext c]- else pprStmtContext c+ ifPprDebug (sep [text "parallel branch of", pprAStmtContext c])+ (pprStmtContext c) pprStmtContext (TransStmtCtxt c) =- sdocWithPprDebug $ \dbg -> if dbg- then sep [text "transformed branch of", pprAStmtContext c]- else pprStmtContext c+ ifPprDebug (sep [text "transformed branch of", pprAStmtContext c])+ (pprStmtContext c) -instance (Outputable id, Outputable (NameOrRdrName id))- => Outputable (HsStmtContext id) where+instance (Outputable p, Outputable (NameOrRdrName p))+ => Outputable (HsStmtContext p) where ppr = pprStmtContext -- Used to generate the string for a *runtime* error message@@ -2531,17 +2591,19 @@ matchContextErrString (StmtCtxt MonadComp) = text "monad comprehension" matchContextErrString (StmtCtxt PArrComp) = text "array comprehension" -pprMatchInCtxt :: (OutputableBndrId idR,- Outputable (NameOrRdrName (NameOrRdrName idR)),+pprMatchInCtxt :: (SourceTextX idR, OutputableBndrId idR,+ -- TODO:AZ these constraints do not make sense+ Outputable (NameOrRdrName (NameOrRdrName (IdP idR))), Outputable body) => Match idR body -> SDoc pprMatchInCtxt match = hang (text "In" <+> pprMatchContext (m_ctxt match) <> colon) 4 (pprMatch match) -pprStmtInCtxt :: (OutputableBndrId idL, OutputableBndrId idR,+pprStmtInCtxt :: (SourceTextX idL, SourceTextX idR,+ OutputableBndrId idL, OutputableBndrId idR, Outputable body)- => HsStmtContext idL -> StmtLR idL idR body -> SDoc+ => HsStmtContext (IdP idL) -> StmtLR idL idR body -> SDoc pprStmtInCtxt ctxt (LastStmt e _ _) | isListCompExpr ctxt -- For [ e | .. ], do not mutter about "stmts" = hang (text "In the expression:") 2 (ppr e)
hsSyn/HsExpr.hs-boot view
@@ -4,6 +4,7 @@ -- in module PlaceHolder {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ExistentialQuantification #-} module HsExpr where @@ -11,7 +12,7 @@ import Outputable ( SDoc, Outputable ) import {-# SOURCE #-} HsPat ( LPat ) import BasicTypes ( SpliceExplicitFlag(..))-import PlaceHolder ( DataId, OutputableBndrId )+import HsExtension ( OutputableBndrId, DataId, SourceTextX ) import Data.Data hiding ( Fixity ) type role HsExpr nominal@@ -27,31 +28,32 @@ data GRHSs (a :: *) (body :: *) data SyntaxExpr (i :: *) -instance (DataId id) => Data (HsSplice id)-instance (DataId id) => Data (HsExpr id)-instance (DataId id) => Data (HsCmd id)-instance (Data body,DataId id) => Data (MatchGroup id body)-instance (Data body,DataId id) => Data (GRHSs id body)-instance (DataId id) => Data (SyntaxExpr id)+instance (DataId p) => Data (HsSplice p)+instance (DataId p) => Data (HsExpr p)+instance (DataId p) => Data (HsCmd p)+instance (Data body,DataId p) => Data (MatchGroup p body)+instance (Data body,DataId p) => Data (GRHSs p body)+instance (DataId p) => Data (SyntaxExpr p) -instance (OutputableBndrId id) => Outputable (HsExpr id)-instance (OutputableBndrId id) => Outputable (HsCmd id)+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsExpr p)+instance (SourceTextX p, OutputableBndrId p) => Outputable (HsCmd p) type LHsExpr a = Located (HsExpr a) -pprLExpr :: (OutputableBndrId id) => LHsExpr id -> SDoc+pprLExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc -pprExpr :: (OutputableBndrId id) => HsExpr id -> SDoc+pprExpr :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc -pprSplice :: (OutputableBndrId id) => HsSplice id -> SDoc+pprSplice :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SDoc -pprSpliceDecl :: (OutputableBndrId id)- => HsSplice id -> SpliceExplicitFlag -> SDoc+pprSpliceDecl :: (SourceTextX p, OutputableBndrId p)+ => HsSplice p -> SpliceExplicitFlag -> SDoc -pprPatBind :: (OutputableBndrId bndr,- OutputableBndrId id,- Outputable body)- => LPat bndr -> GRHSs id body -> SDoc+pprPatBind :: forall bndr p body. (SourceTextX p, SourceTextX bndr,+ OutputableBndrId bndr,+ OutputableBndrId p,+ Outputable body)+ => LPat bndr -> GRHSs p body -> SDoc -pprFunBind :: (OutputableBndrId idR, Outputable body)+pprFunBind :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc
+ hsSyn/HsExtension.hs view
@@ -0,0 +1,291 @@+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE StandaloneDeriving #-}++module HsExtension where++-- This module captures the type families to precisely identify the extension+-- points for HsSyn++import GhcPrelude++import GHC.Exts (Constraint)+import Data.Data hiding ( Fixity )+import PlaceHolder+import BasicTypes+import ConLike+import NameSet+import Name+import RdrName+import Var+import Type ( Type )+import Outputable+import SrcLoc (Located)+import Coercion+import TcEvidence++{-+Note [Trees that grow]+~~~~~~~~~~~~~~~~~~~~~~++See https://ghc.haskell.org/trac/ghc/wiki/ImplementingTreesThatGrow++The hsSyn AST is reused across multiple compiler passes. We also have the+Template Haskell AST, and the haskell-src-exts one (outside of GHC)++Supporting multiple passes means the AST has various warts on it to cope with+the specifics for the phases, such as the 'ValBindsOut', 'ConPatOut',+'SigPatOut' etc.++The growable AST will allow each of these variants to be captured explicitly,+such that they only exist in the given compiler pass AST, as selected by the+type parameter to the AST.++In addition it will allow tool writers to define their own extensions to capture+additional information for the tool, in a natural way.++A further goal is to provide a means to harmonise the Template Haskell and+haskell-src-exts ASTs as well.++-}++-- | Used as a data type index for the hsSyn AST+data GhcPass (c :: Pass)+deriving instance Eq (GhcPass c)+deriving instance Typeable c => Data (GhcPass c)++data Pass = Parsed | Renamed | Typechecked+ deriving (Data)++-- Type synonyms as a shorthand for tagging+type GhcPs = GhcPass 'Parsed -- Old 'RdrName' type param+type GhcRn = GhcPass 'Renamed -- Old 'Name' type param+type GhcTc = GhcPass 'Typechecked -- Old 'Id' type para,+type GhcTcId = GhcTc -- Old 'TcId' type param+++-- | Types that are not defined until after type checking+type family PostTc x ty -- Note [Pass sensitive types] in PlaceHolder+type instance PostTc GhcPs ty = PlaceHolder+type instance PostTc GhcRn ty = PlaceHolder+type instance PostTc GhcTc ty = ty++-- | Types that are not defined until after renaming+type family PostRn x ty -- Note [Pass sensitive types] in PlaceHolder+type instance PostRn GhcPs ty = PlaceHolder+type instance PostRn GhcRn ty = ty+type instance PostRn GhcTc ty = ty++-- | Maps the "normal" id type for a given pass+type family IdP p+type instance IdP GhcPs = RdrName+type instance IdP GhcRn = Name+type instance IdP GhcTc = Id+++-- We define a type family for each extension point. This is based on prepending+-- 'X' to the constructor name, for ease of reference.+type family XHsChar x+type family XHsCharPrim x+type family XHsString x+type family XHsStringPrim x+type family XHsInt x+type family XHsIntPrim x+type family XHsWordPrim x+type family XHsInt64Prim x+type family XHsWord64Prim x+type family XHsInteger x+type family XHsRat x+type family XHsFloatPrim x+type family XHsDoublePrim x++-- | Helper to apply a constraint to all extension points. It has one+-- entry per extension point type family.+type ForallX (c :: * -> Constraint) (x :: *) =+ ( c (XHsChar x)+ , c (XHsCharPrim x)+ , c (XHsString x)+ , c (XHsStringPrim x)+ , c (XHsInt x)+ , c (XHsIntPrim x)+ , c (XHsWordPrim x)+ , c (XHsInt64Prim x)+ , c (XHsWord64Prim x)+ , c (XHsInteger x)+ , c (XHsRat x)+ , c (XHsFloatPrim x)+ , c (XHsDoublePrim x)+ )+++-- Provide the specific extension types for the parser phase.+type instance XHsChar GhcPs = SourceText+type instance XHsCharPrim GhcPs = SourceText+type instance XHsString GhcPs = SourceText+type instance XHsStringPrim GhcPs = SourceText+type instance XHsInt GhcPs = ()+type instance XHsIntPrim GhcPs = SourceText+type instance XHsWordPrim GhcPs = SourceText+type instance XHsInt64Prim GhcPs = SourceText+type instance XHsWord64Prim GhcPs = SourceText+type instance XHsInteger GhcPs = SourceText+type instance XHsRat GhcPs = ()+type instance XHsFloatPrim GhcPs = ()+type instance XHsDoublePrim GhcPs = ()++-- Provide the specific extension types for the renamer phase.+type instance XHsChar GhcRn = SourceText+type instance XHsCharPrim GhcRn = SourceText+type instance XHsString GhcRn = SourceText+type instance XHsStringPrim GhcRn = SourceText+type instance XHsInt GhcRn = ()+type instance XHsIntPrim GhcRn = SourceText+type instance XHsWordPrim GhcRn = SourceText+type instance XHsInt64Prim GhcRn = SourceText+type instance XHsWord64Prim GhcRn = SourceText+type instance XHsInteger GhcRn = SourceText+type instance XHsRat GhcRn = ()+type instance XHsFloatPrim GhcRn = ()+type instance XHsDoublePrim GhcRn = ()++-- Provide the specific extension types for the typechecker phase.+type instance XHsChar GhcTc = SourceText+type instance XHsCharPrim GhcTc = SourceText+type instance XHsString GhcTc = SourceText+type instance XHsStringPrim GhcTc = SourceText+type instance XHsInt GhcTc = ()+type instance XHsIntPrim GhcTc = SourceText+type instance XHsWordPrim GhcTc = SourceText+type instance XHsInt64Prim GhcTc = SourceText+type instance XHsWord64Prim GhcTc = SourceText+type instance XHsInteger GhcTc = SourceText+type instance XHsRat GhcTc = ()+type instance XHsFloatPrim GhcTc = ()+type instance XHsDoublePrim GhcTc = ()+++-- ---------------------------------------------------------------------++-- | The 'SourceText' fields have been moved into the extension fields, thus+-- placing a requirement in the extension field to contain a 'SourceText' so+-- that the pretty printing and round tripping of source can continue to+-- operate.+--+-- The 'HasSourceText' class captures this requirement for the relevant fields.+class HasSourceText a where+ -- Provide setters to mimic existing constructors+ noSourceText :: a+ sourceText :: String -> a++ setSourceText :: SourceText -> a+ getSourceText :: a -> SourceText++-- | Provide a summary constraint that lists all the extension points requiring+-- the 'HasSourceText' class, so that it can be changed in one place as the+-- named extensions change throughout the AST.+type SourceTextX x =+ ( HasSourceText (XHsChar x)+ , HasSourceText (XHsCharPrim x)+ , HasSourceText (XHsString x)+ , HasSourceText (XHsStringPrim x)+ , HasSourceText (XHsIntPrim x)+ , HasSourceText (XHsWordPrim x)+ , HasSourceText (XHsInt64Prim x)+ , HasSourceText (XHsWord64Prim x)+ , HasSourceText (XHsInteger x)+ )+++-- | 'SourceText' trivially implements 'HasSourceText'+instance HasSourceText SourceText where+ noSourceText = NoSourceText+ sourceText s = SourceText s++ setSourceText s = s+ getSourceText a = a+++-- ----------------------------------------------------------------------+-- | Defaults for each annotation, used to simplify creation in arbitrary+-- contexts+class HasDefault a where+ def :: a++instance HasDefault () where+ def = ()++instance HasDefault SourceText where+ def = NoSourceText++-- | Provide a single constraint that captures the requirement for a default+-- across all the extension points.+type HasDefaultX x = ForallX HasDefault x++-- ----------------------------------------------------------------------+-- | Conversion of annotations from one type index to another. This is required+-- where the AST is converted from one pass to another, and the extension values+-- need to be brought along if possible. So for example a 'SourceText' is+-- converted via 'id', but needs a type signature to keep the type checker+-- happy.+class Convertable a b | a -> b where+ convert :: a -> b++instance Convertable a a where+ convert = id++-- | A constraint capturing all the extension points that can be converted via+-- @instance Convertable a a@+type ConvertIdX a b =+ (XHsDoublePrim a ~ XHsDoublePrim b,+ XHsFloatPrim a ~ XHsFloatPrim b,+ XHsRat a ~ XHsRat b,+ XHsInteger a ~ XHsInteger b,+ XHsWord64Prim a ~ XHsWord64Prim b,+ XHsInt64Prim a ~ XHsInt64Prim b,+ XHsWordPrim a ~ XHsWordPrim b,+ XHsIntPrim a ~ XHsIntPrim b,+ XHsInt a ~ XHsInt b,+ XHsStringPrim a ~ XHsStringPrim b,+ XHsString a ~ XHsString b,+ XHsCharPrim a ~ XHsCharPrim b,+ XHsChar a ~ XHsChar b)+++-- ----------------------------------------------------------------------++--+type DataId p =+ ( Data p+ , ForallX Data p+ , Data (NameOrRdrName (IdP p))++ , Data (IdP p)+ , Data (PostRn p (IdP p))+ , Data (PostRn p (Located Name))+ , Data (PostRn p Bool)+ , Data (PostRn p Fixity)+ , Data (PostRn p NameSet)+ , Data (PostRn p [Name])++ , Data (PostTc p (IdP p))+ , Data (PostTc p Coercion)+ , Data (PostTc p ConLike)+ , Data (PostTc p HsWrapper)+ , Data (PostTc p Type)+ , Data (PostTc p [ConLike])+ , Data (PostTc p [Type])+ )+++-- |Constraint type to bundle up the requirement for 'OutputableBndr' on both+-- the @id@ and the 'NameOrRdrName' type for it+type OutputableBndrId id =+ ( OutputableBndr (NameOrRdrName (IdP id))+ , OutputableBndr (IdP id)+ )
hsSyn/HsImpExp.hs view
@@ -7,9 +7,15 @@ -} {-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]+ -- in module PlaceHolder module HsImpExp where +import GhcPrelude+ import Module ( ModuleName ) import HsDoc ( HsDocString ) import OccName ( HasOccName(..), isTcOcc, isSymOcc )@@ -19,6 +25,7 @@ import Outputable import FastString import SrcLoc+import HsExtension import Data.Data @@ -73,7 +80,7 @@ -- to location in ideclHiding -- For details on above see note [Api annotations] in ApiAnnotation- deriving Data+deriving instance (DataId name) => Data (ImportDecl name) simpleImportDecl :: ModuleName -> ImportDecl name simpleImportDecl mn = ImportDecl {@@ -88,7 +95,7 @@ ideclHiding = Nothing } -instance (OutputableBndr name, HasOccName name) => Outputable (ImportDecl name) where+instance (OutputableBndrId pass) => Outputable (ImportDecl pass) where ppr (ImportDecl { ideclSourceSrc = mSrcText, ideclName = mod' , ideclPkgQual = pkg , ideclSource = from, ideclSafe = safe@@ -134,7 +141,7 @@ ************************************************************************ -} --- | A name in an import or export specfication which may have adornments. Used+-- | A name in an import or export specification which may have adornments. Used -- primarily for accurate pretty printing of ParsedSource, and API Annotation -- placement. data IEWrappedName name@@ -160,10 +167,10 @@ -- | Imported or exported entity. data IE name- = IEVar (LIEWrappedName name)+ = IEVar (LIEWrappedName (IdP name)) -- ^ Imported or Exported Variable - | IEThingAbs (LIEWrappedName name)+ | IEThingAbs (LIEWrappedName (IdP name)) -- ^ Imported or exported Thing with Absent list -- -- The thing is a Class/Type (can't tell)@@ -172,7 +179,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation -- See Note [Located RdrNames] in HsExpr- | IEThingAll (LIEWrappedName name)+ | IEThingAll (LIEWrappedName (IdP name)) -- ^ Imported or exported Thing with All imported or exported -- -- The thing is a Class/Type and the All refers to methods/constructors@@ -184,10 +191,10 @@ -- For details on above see note [Api annotations] in ApiAnnotation -- See Note [Located RdrNames] in HsExpr - | IEThingWith (LIEWrappedName name)+ | IEThingWith (LIEWrappedName (IdP name)) IEWildcard- [LIEWrappedName name]- [Located (FieldLbl name)]+ [LIEWrappedName (IdP name)]+ [Located (FieldLbl (IdP name))] -- ^ Imported or exported Thing With given imported or exported -- -- The thing is a Class/Type and the imported or exported things are@@ -209,7 +216,9 @@ | IEGroup Int HsDocString -- ^ Doc section heading | IEDoc HsDocString -- ^ Some documentation | IEDocNamed String -- ^ Reference to named doc- deriving (Eq, Data)+ -- deriving (Eq, Data)+deriving instance (Eq name, Eq (IdP name)) => Eq (IE name)+deriving instance (DataId name) => Data (IE name) -- | Imported or Exported Wildcard data IEWildcard = NoIEWildcard | IEWildcard Int deriving (Eq, Data)@@ -231,14 +240,14 @@ See Note [Representing fields in AvailInfo] in Avail for more details. -} -ieName :: IE name -> name+ieName :: IE pass -> IdP pass ieName (IEVar (L _ n)) = ieWrappedName n ieName (IEThingAbs (L _ n)) = ieWrappedName n ieName (IEThingWith (L _ n) _ _ _) = ieWrappedName n ieName (IEThingAll (L _ n)) = ieWrappedName n ieName _ = panic "ieName failed pattern match!" -ieNames :: IE a -> [a]+ieNames :: IE pass -> [IdP pass] ieNames (IEVar (L _ n) ) = [ieWrappedName n] ieNames (IEThingAbs (L _ n) ) = [ieWrappedName n] ieNames (IEThingAll (L _ n) ) = [ieWrappedName n]@@ -265,7 +274,7 @@ replaceLWrappedName :: LIEWrappedName name1 -> name2 -> LIEWrappedName name2 replaceLWrappedName (L l n) n' = L l (replaceWrappedName n n') -instance (HasOccName name, OutputableBndr name) => Outputable (IE name) where+instance (OutputableBndrId pass) => Outputable (IE pass) where ppr (IEVar var) = ppr (unLoc var) ppr (IEThingAbs thing) = ppr (unLoc thing) ppr (IEThingAll thing) = hcat [ppr (unLoc thing), text "(..)"]@@ -290,14 +299,12 @@ instance (HasOccName name) => HasOccName (IEWrappedName name) where occName w = occName (ieWrappedName w) -instance (OutputableBndr name, HasOccName name)- => OutputableBndr (IEWrappedName name) where+instance (OutputableBndr name) => OutputableBndr (IEWrappedName name) where pprBndr bs w = pprBndr bs (ieWrappedName w) pprPrefixOcc w = pprPrefixOcc (ieWrappedName w) pprInfixOcc w = pprInfixOcc (ieWrappedName w) -instance (HasOccName name, OutputableBndr name)- => Outputable (IEWrappedName name) where+instance (OutputableBndr name) => Outputable (IEWrappedName name) where ppr (IEName n) = pprPrefixOcc (unLoc n) ppr (IEPattern n) = text "pattern" <+> pprPrefixOcc (unLoc n) ppr (IEType n) = text "type" <+> pprPrefixOcc (unLoc n)
hsSyn/HsLit.hs view
@@ -13,17 +13,21 @@ {-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types] -- in module PlaceHolder {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TypeFamilies #-} module HsLit where #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} HsExpr( HsExpr, pprExpr )-import BasicTypes ( FractionalLit(..),SourceText(..),pprWithSourceText )+import BasicTypes ( IntegralLit(..),FractionalLit(..),negateIntegralLit,+ negateFractionalLit,SourceText(..),pprWithSourceText ) import Type ( Type ) import Outputable import FastString-import PlaceHolder ( PostTc,PostRn,DataId,OutputableBndrId )+import HsExtension import Data.ByteString (ByteString) import Data.Data hiding ( Fixity )@@ -38,42 +42,45 @@ -- Note [Literal source text] in BasicTypes for SourceText fields in -- the following+-- Note [Trees that grow] in HsExtension for the Xxxxx fields in the following -- | Haskell Literal-data HsLit- = HsChar SourceText Char+data HsLit x+ = HsChar (XHsChar x) {- SourceText -} Char -- ^ Character- | HsCharPrim SourceText Char+ | HsCharPrim (XHsCharPrim x) {- SourceText -} Char -- ^ Unboxed character- | HsString SourceText FastString+ | HsString (XHsString x) {- SourceText -} FastString -- ^ String- | HsStringPrim SourceText ByteString+ | HsStringPrim (XHsStringPrim x) {- SourceText -} ByteString -- ^ Packed bytes- | HsInt SourceText Integer+ | HsInt (XHsInt x) IntegralLit -- ^ Genuinely an Int; arises from -- @TcGenDeriv@, and from TRANSLATION- | HsIntPrim SourceText Integer+ | HsIntPrim (XHsIntPrim x) {- SourceText -} Integer -- ^ literal @Int#@- | HsWordPrim SourceText Integer+ | HsWordPrim (XHsWordPrim x) {- SourceText -} Integer -- ^ literal @Word#@- | HsInt64Prim SourceText Integer+ | HsInt64Prim (XHsInt64Prim x) {- SourceText -} Integer -- ^ literal @Int64#@- | HsWord64Prim SourceText Integer+ | HsWord64Prim (XHsWord64Prim x) {- SourceText -} Integer -- ^ literal @Word64#@- | HsInteger SourceText Integer Type+ | HsInteger (XHsInteger x) {- SourceText -} Integer Type -- ^ Genuinely an integer; arises only -- from TRANSLATION (overloaded -- literals are done with HsOverLit)- | HsRat FractionalLit Type+ | HsRat (XHsRat x) FractionalLit Type -- ^ Genuinely a rational; arises only from -- TRANSLATION (overloaded literals are -- done with HsOverLit)- | HsFloatPrim FractionalLit+ | HsFloatPrim (XHsFloatPrim x) FractionalLit -- ^ Unboxed Float- | HsDoublePrim FractionalLit+ | HsDoublePrim (XHsDoublePrim x) FractionalLit -- ^ Unboxed Double- deriving Data -instance Eq HsLit where+deriving instance (DataId x) => Data (HsLit x)+++instance Eq (HsLit x) where (HsChar _ x1) == (HsChar _ x2) = x1==x2 (HsCharPrim _ x1) == (HsCharPrim _ x2) = x1==x2 (HsString _ x1) == (HsString _ x2) = x1==x2@@ -84,32 +91,54 @@ (HsInt64Prim _ x1) == (HsInt64Prim _ x2) = x1==x2 (HsWord64Prim _ x1) == (HsWord64Prim _ x2) = x1==x2 (HsInteger _ x1 _) == (HsInteger _ x2 _) = x1==x2- (HsRat x1 _) == (HsRat x2 _) = x1==x2- (HsFloatPrim x1) == (HsFloatPrim x2) = x1==x2- (HsDoublePrim x1) == (HsDoublePrim x2) = x1==x2+ (HsRat _ x1 _) == (HsRat _ x2 _) = x1==x2+ (HsFloatPrim _ x1) == (HsFloatPrim _ x2) = x1==x2+ (HsDoublePrim _ x1) == (HsDoublePrim _ x2) = x1==x2 _ == _ = False -- | Haskell Overloaded Literal-data HsOverLit id+data HsOverLit p = OverLit { ol_val :: OverLitVal,- ol_rebindable :: PostRn id Bool, -- Note [ol_rebindable]- ol_witness :: HsExpr id, -- Note [Overloaded literal witnesses]- ol_type :: PostTc id Type }-deriving instance (DataId id) => Data (HsOverLit id)+ ol_rebindable :: PostRn p Bool, -- Note [ol_rebindable]+ ol_witness :: HsExpr p, -- Note [Overloaded literal witnesses]+ ol_type :: PostTc p Type }+deriving instance (DataId p) => Data (HsOverLit p) -- Note [Literal source text] in BasicTypes for SourceText fields in -- the following -- | Overloaded Literal Value data OverLitVal- = HsIntegral !SourceText !Integer -- ^ Integer-looking literals;+ = HsIntegral !IntegralLit -- ^ Integer-looking literals; | HsFractional !FractionalLit -- ^ Frac-looking literals | HsIsString !SourceText !FastString -- ^ String-looking literals deriving Data -overLitType :: HsOverLit a -> PostTc a Type+negateOverLitVal :: OverLitVal -> OverLitVal+negateOverLitVal (HsIntegral i) = HsIntegral (negateIntegralLit i)+negateOverLitVal (HsFractional f) = HsFractional (negateFractionalLit f)+negateOverLitVal _ = panic "negateOverLitVal: argument is not a number"++overLitType :: HsOverLit p -> PostTc p Type overLitType = ol_type +-- | Convert a literal from one index type to another, updating the annotations+-- according to the relevant 'Convertable' instance+convertLit :: (ConvertIdX a b) => HsLit a -> HsLit b+convertLit (HsChar a x) = (HsChar (convert a) x)+convertLit (HsCharPrim a x) = (HsCharPrim (convert a) x)+convertLit (HsString a x) = (HsString (convert a) x)+convertLit (HsStringPrim a x) = (HsStringPrim (convert a) x)+convertLit (HsInt a x) = (HsInt (convert a) x)+convertLit (HsIntPrim a x) = (HsIntPrim (convert a) x)+convertLit (HsWordPrim a x) = (HsWordPrim (convert a) x)+convertLit (HsInt64Prim a x) = (HsInt64Prim (convert a) x)+convertLit (HsWord64Prim a x) = (HsWord64Prim (convert a) x)+convertLit (HsInteger a x b) = (HsInteger (convert a) x b)+convertLit (HsRat a x b) = (HsRat (convert a) x b)+convertLit (HsFloatPrim a x) = (HsFloatPrim (convert a) x)+convertLit (HsDoublePrim a x) = (HsDoublePrim (convert a) x)+ {- Note [ol_rebindable] ~~~~~~~~~~~~~~~~~~~~@@ -134,7 +163,7 @@ This dual role is unusual, because we're replacing 'fromInteger' with a call to fromInteger. Reason: it allows commoning up of the fromInteger-calls, which wouldn't be possible if the desguarar made the application.+calls, which wouldn't be possible if the desugarer made the application. The PostTcType in each branch records the type the overload literal is found to have.@@ -142,55 +171,65 @@ -- Comparison operations are needed when grouping literals -- for compiling pattern-matching (module MatchLit)-instance Eq (HsOverLit id) where+instance Eq (HsOverLit p) where (OverLit {ol_val = val1}) == (OverLit {ol_val=val2}) = val1 == val2 instance Eq OverLitVal where- (HsIntegral _ i1) == (HsIntegral _ i2) = i1 == i2+ (HsIntegral i1) == (HsIntegral i2) = i1 == i2 (HsFractional f1) == (HsFractional f2) = f1 == f2 (HsIsString _ s1) == (HsIsString _ s2) = s1 == s2 _ == _ = False -instance Ord (HsOverLit id) where+instance Ord (HsOverLit p) where compare (OverLit {ol_val=val1}) (OverLit {ol_val=val2}) = val1 `compare` val2 instance Ord OverLitVal where- compare (HsIntegral _ i1) (HsIntegral _ i2) = i1 `compare` i2- compare (HsIntegral _ _) (HsFractional _) = LT- compare (HsIntegral _ _) (HsIsString _ _) = LT+ compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2+ compare (HsIntegral _) (HsFractional _) = LT+ compare (HsIntegral _) (HsIsString _ _) = LT compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2- compare (HsFractional _) (HsIntegral _ _) = GT+ compare (HsFractional _) (HsIntegral _) = GT compare (HsFractional _) (HsIsString _ _) = LT compare (HsIsString _ s1) (HsIsString _ s2) = s1 `compare` s2- compare (HsIsString _ _) (HsIntegral _ _) = GT+ compare (HsIsString _ _) (HsIntegral _) = GT compare (HsIsString _ _) (HsFractional _) = GT -instance Outputable HsLit where- ppr (HsChar st c) = pprWithSourceText st (pprHsChar c)- ppr (HsCharPrim st c) = pp_st_suffix st primCharSuffix (pprPrimChar c)- ppr (HsString st s) = pprWithSourceText st (pprHsString s)- ppr (HsStringPrim st s) = pprWithSourceText st (pprHsBytes s)- ppr (HsInt st i) = pprWithSourceText st (integer i)- ppr (HsInteger st i _) = pprWithSourceText st (integer i)- ppr (HsRat f _) = ppr f- ppr (HsFloatPrim f) = ppr f <> primFloatSuffix- ppr (HsDoublePrim d) = ppr d <> primDoubleSuffix- ppr (HsIntPrim st i) = pprWithSourceText st (pprPrimInt i)- ppr (HsWordPrim st w) = pprWithSourceText st (pprPrimWord w)- ppr (HsInt64Prim st i) = pp_st_suffix st primInt64Suffix (pprPrimInt64 i)- ppr (HsWord64Prim st w) = pp_st_suffix st primWord64Suffix (pprPrimWord64 w)+-- Instance specific to GhcPs, need the SourceText+instance (SourceTextX x) => Outputable (HsLit x) where+ ppr (HsChar st c) = pprWithSourceText (getSourceText st) (pprHsChar c)+ ppr (HsCharPrim st c)+ = pp_st_suffix (getSourceText st) primCharSuffix (pprPrimChar c)+ ppr (HsString st s)+ = pprWithSourceText (getSourceText st) (pprHsString s)+ ppr (HsStringPrim st s)+ = pprWithSourceText (getSourceText st) (pprHsBytes s)+ ppr (HsInt _ i)+ = pprWithSourceText (il_text i) (integer (il_value i))+ ppr (HsInteger st i _) = pprWithSourceText (getSourceText st) (integer i)+ ppr (HsRat _ f _) = ppr f+ ppr (HsFloatPrim _ f) = ppr f <> primFloatSuffix+ ppr (HsDoublePrim _ d) = ppr d <> primDoubleSuffix+ ppr (HsIntPrim st i)+ = pprWithSourceText (getSourceText st) (pprPrimInt i)+ ppr (HsWordPrim st w)+ = pprWithSourceText (getSourceText st) (pprPrimWord w)+ ppr (HsInt64Prim st i)+ = pp_st_suffix (getSourceText st) primInt64Suffix (pprPrimInt64 i)+ ppr (HsWord64Prim st w)+ = pp_st_suffix (getSourceText st) primWord64Suffix (pprPrimWord64 w) pp_st_suffix :: SourceText -> SDoc -> SDoc -> SDoc pp_st_suffix NoSourceText _ doc = doc pp_st_suffix (SourceText st) suffix _ = text st <> suffix -- in debug mode, print the expression that it's resolved to, too-instance (OutputableBndrId id) => Outputable (HsOverLit id) where+instance (SourceTextX p, OutputableBndrId p)+ => Outputable (HsOverLit p) where ppr (OverLit {ol_val=val, ol_witness=witness})- = ppr val <+> (ifPprDebug (parens (pprExpr witness)))+ = ppr val <+> (whenPprDebug (parens (pprExpr witness))) instance Outputable OverLitVal where- ppr (HsIntegral st i) = pprWithSourceText st (integer i)+ ppr (HsIntegral i) = pprWithSourceText (il_text i) (integer (il_value i)) ppr (HsFractional f) = ppr f ppr (HsIsString st s) = pprWithSourceText st (pprHsString s) @@ -200,17 +239,44 @@ -- mainly for too reasons: -- * We do not want to expose their internal representation -- * The warnings become too messy-pmPprHsLit :: HsLit -> SDoc+pmPprHsLit :: (SourceTextX x) => HsLit x -> SDoc pmPprHsLit (HsChar _ c) = pprHsChar c pmPprHsLit (HsCharPrim _ c) = pprHsChar c-pmPprHsLit (HsString st s) = pprWithSourceText st (pprHsString s)+pmPprHsLit (HsString st s) = pprWithSourceText (getSourceText st)+ (pprHsString s) pmPprHsLit (HsStringPrim _ s) = pprHsBytes s-pmPprHsLit (HsInt _ i) = integer i+pmPprHsLit (HsInt _ i) = integer (il_value i) pmPprHsLit (HsIntPrim _ i) = integer i pmPprHsLit (HsWordPrim _ w) = integer w pmPprHsLit (HsInt64Prim _ i) = integer i pmPprHsLit (HsWord64Prim _ w) = integer w pmPprHsLit (HsInteger _ i _) = integer i-pmPprHsLit (HsRat f _) = ppr f-pmPprHsLit (HsFloatPrim f) = ppr f-pmPprHsLit (HsDoublePrim d) = ppr d+pmPprHsLit (HsRat _ f _) = ppr f+pmPprHsLit (HsFloatPrim _ f) = ppr f+pmPprHsLit (HsDoublePrim _ d) = ppr d++-- | Returns 'True' for compound literals that will need parentheses.+isCompoundHsLit :: HsLit x -> Bool+isCompoundHsLit (HsChar {}) = False+isCompoundHsLit (HsCharPrim {}) = False+isCompoundHsLit (HsString {}) = False+isCompoundHsLit (HsStringPrim {}) = False+isCompoundHsLit (HsInt _ x) = il_neg x+isCompoundHsLit (HsIntPrim _ x) = x < 0+isCompoundHsLit (HsWordPrim _ x) = x < 0+isCompoundHsLit (HsInt64Prim _ x) = x < 0+isCompoundHsLit (HsWord64Prim _ x) = x < 0+isCompoundHsLit (HsInteger _ x _) = x < 0+isCompoundHsLit (HsRat _ x _) = fl_neg x+isCompoundHsLit (HsFloatPrim _ x) = fl_neg x+isCompoundHsLit (HsDoublePrim _ x) = fl_neg x++-- | Returns 'True' for compound overloaded literals that will need+-- parentheses when used in an argument position.+isCompoundHsOverLit :: HsOverLit x -> Bool+isCompoundHsOverLit (OverLit { ol_val = olv }) = compound_ol_val olv+ where+ compound_ol_val :: OverLitVal -> Bool+ compound_ol_val (HsIntegral x) = il_neg x+ compound_ol_val (HsFractional x) = fl_neg x+ compound_ol_val (HsIsString {}) = False
hsSyn/HsPat.hs view
@@ -29,8 +29,9 @@ mkPrefixConPat, mkCharLitPat, mkNilPat, looksLazyPatBind,- isBangedLPat, isBangedPatBind,+ isBangedLPat, hsPatNeedsParens,+ isCompoundPat, parenthesizeCompoundPat, isIrrefutableHsPat, collectEvVarsPats,@@ -38,12 +39,14 @@ pprParendLPat, pprConArgs ) where +import GhcPrelude+ import {-# SOURCE #-} HsExpr (SyntaxExpr, LHsExpr, HsSplice, pprLExpr, pprSplice) -- friends: import HsBinds import HsLit-import PlaceHolder+import HsExtension import HsTypes import TcEvidence import BasicTypes@@ -64,50 +67,51 @@ -- libraries: import Data.Data hiding (TyCon,Fixity) -type InPat id = LPat id -- No 'Out' constructors-type OutPat id = LPat id -- No 'In' constructors+type InPat p = LPat p -- No 'Out' constructors+type OutPat p = LPat p -- No 'In' constructors -type LPat id = Located (Pat id)+type LPat p = Located (Pat p) -- | Pattern -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnBang' -- For details on above see note [Api annotations] in ApiAnnotation-data Pat id+data Pat p = ------------ Simple patterns ---------------- WildPat (PostTc id Type) -- ^ Wildcard Pattern+ WildPat (PostTc p Type) -- ^ Wildcard Pattern -- The sole reason for a type on a WildPat is to -- support hsPatType :: Pat Id -> Type - | VarPat (Located id) -- ^ Variable Pattern+ -- AZ:TODO above comment needs to be updated+ | VarPat (Located (IdP p)) -- ^ Variable Pattern -- See Note [Located RdrNames] in HsExpr- | LazyPat (LPat id) -- ^ Lazy Pattern+ | LazyPat (LPat p) -- ^ Lazy Pattern -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnTilde' -- For details on above see note [Api annotations] in ApiAnnotation - | AsPat (Located id) (LPat id) -- ^ As pattern+ | AsPat (Located (IdP p)) (LPat p) -- ^ As pattern -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnAt' -- For details on above see note [Api annotations] in ApiAnnotation - | ParPat (LPat id) -- ^ Parenthesised pattern+ | ParPat (LPat p) -- ^ Parenthesised pattern -- See Note [Parens in HsSyn] in HsExpr -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@, -- 'ApiAnnotation.AnnClose' @')'@ -- For details on above see note [Api annotations] in ApiAnnotation- | BangPat (LPat id) -- ^ Bang pattern+ | BangPat (LPat p) -- ^ Bang pattern -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnBang' -- For details on above see note [Api annotations] in ApiAnnotation ------------ Lists, tuples, arrays ---------------- | ListPat [LPat id]- (PostTc id Type) -- The type of the elements- (Maybe (PostTc id Type, SyntaxExpr id)) -- For rebindable syntax+ | ListPat [LPat p]+ (PostTc p Type) -- The type of the elements+ (Maybe (PostTc p Type, SyntaxExpr p)) -- For rebindable syntax -- For OverloadedLists a Just (ty,fn) gives -- overall type of the pattern, and the toList -- function to convert the scrutinee to a list value@@ -118,11 +122,11 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | TuplePat [LPat id] -- Tuple sub-patterns+ | TuplePat [LPat p] -- Tuple sub-patterns Boxity -- UnitPat is TuplePat []- [PostTc id Type] -- [] before typechecker, filled in afterwards+ [PostTc p Type] -- [] before typechecker, filled in afterwards -- with the types of the tuple components- -- You might think that the PostTc id Type was redundant, because we can+ -- You might think that the PostTc p Type was redundant, because we can -- get the pattern type by getting the types of the sub-patterns. -- But it's essential -- data T a where@@ -143,10 +147,10 @@ -- 'ApiAnnotation.AnnOpen' @'('@ or @'(#'@, -- 'ApiAnnotation.AnnClose' @')'@ or @'#)'@ - | SumPat (LPat id) -- Sum sub-pattern+ | SumPat (LPat p) -- Sum sub-pattern ConTag -- Alternative (one-based)- Arity -- Arity- (PostTc id [Type]) -- PlaceHolder before typechecker, filled in+ Arity -- Arity (INVARIANT: ≥ 2)+ (PostTc p [Type]) -- PlaceHolder before typechecker, filled in -- afterwards with the types of the -- alternative -- ^ Anonymous sum pattern@@ -156,15 +160,15 @@ -- 'ApiAnnotation.AnnClose' @'#)'@ -- For details on above see note [Api annotations] in ApiAnnotation- | PArrPat [LPat id] -- Syntactic parallel array- (PostTc id Type) -- The type of the elements+ | PArrPat [LPat p] -- Syntactic parallel array+ (PostTc p Type) -- The type of the elements -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'[:'@, -- 'ApiAnnotation.AnnClose' @':]'@ -- For details on above see note [Api annotations] in ApiAnnotation ------------ Constructor patterns ---------------- | ConPatIn (Located id)- (HsConPatDetails id)+ | ConPatIn (Located (IdP p))+ (HsConPatDetails p) -- ^ Constructor Pattern In | ConPatOut {@@ -181,7 +185,7 @@ -- is to ensure their kinds are zonked pat_binds :: TcEvBinds, -- Bindings involving those dictionaries- pat_args :: HsConPatDetails id,+ pat_args :: HsConPatDetails p, pat_wrap :: HsWrapper -- Extra wrapper to pass to the matcher -- Only relevant for pattern-synonyms; -- ignored for data cons@@ -192,9 +196,9 @@ -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow' -- For details on above see note [Api annotations] in ApiAnnotation- | ViewPat (LHsExpr id)- (LPat id)- (PostTc id Type) -- The overall type of the pattern+ | ViewPat (LHsExpr p)+ (LPat p)+ (PostTc p Type) -- The overall type of the pattern -- (= the argument type of the view function) -- for hsPatType. -- ^ View Pattern@@ -204,68 +208,69 @@ -- 'ApiAnnotation.AnnClose' @')'@ -- For details on above see note [Api annotations] in ApiAnnotation- | SplicePat (HsSplice id) -- ^ Splice Pattern (Includes quasi-quotes)+ | SplicePat (HsSplice p) -- ^ Splice Pattern (Includes quasi-quotes) ------------ Literal and n+k patterns ---------------- | LitPat HsLit -- ^ Literal Pattern+ | LitPat (HsLit p) -- ^ Literal Pattern -- Used for *non-overloaded* literal patterns: -- Int#, Char#, Int, Char, String, etc. | NPat -- Natural Pattern -- Used for all overloaded literals, -- including overloaded strings with -XOverloadedStrings- (Located (HsOverLit id)) -- ALWAYS positive- (Maybe (SyntaxExpr id)) -- Just (Name of 'negate') for negative- -- patterns, Nothing otherwise- (SyntaxExpr id) -- Equality checker, of type t->t->Bool- (PostTc id Type) -- Overall type of pattern. Might be- -- different than the literal's type- -- if (==) or negate changes the type+ (Located (HsOverLit p)) -- ALWAYS positive+ (Maybe (SyntaxExpr p)) -- Just (Name of 'negate') for+ -- negative patterns, Nothing+ -- otherwise+ (SyntaxExpr p) -- Equality checker, of type t->t->Bool+ (PostTc p Type) -- Overall type of pattern. Might be+ -- different than the literal's type+ -- if (==) or negate changes the type -- ^ Natural Pattern -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnVal' @'+'@ -- For details on above see note [Api annotations] in ApiAnnotation- | NPlusKPat (Located id) -- n+k pattern- (Located (HsOverLit id)) -- It'll always be an HsIntegral- (HsOverLit id) -- See Note [NPlusK patterns] in TcPat+ | NPlusKPat (Located (IdP p)) -- n+k pattern+ (Located (HsOverLit p)) -- It'll always be an HsIntegral+ (HsOverLit p) -- See Note [NPlusK patterns] in TcPat -- NB: This could be (PostTc ...), but that induced a -- a new hs-boot file. Not worth it. - (SyntaxExpr id) -- (>=) function, of type t1->t2->Bool- (SyntaxExpr id) -- Name of '-' (see RnEnv.lookupSyntaxName)- (PostTc id Type) -- Type of overall pattern+ (SyntaxExpr p) -- (>=) function, of type t1->t2->Bool+ (SyntaxExpr p) -- Name of '-' (see RnEnv.lookupSyntaxName)+ (PostTc p Type) -- Type of overall pattern -- ^ n+k pattern ------------ Pattern type signatures --------------- -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -- For details on above see note [Api annotations] in ApiAnnotation- | SigPatIn (LPat id) -- Pattern with a type signature- (LHsSigWcType id) -- Signature can bind both+ | SigPatIn (LPat p) -- Pattern with a type signature+ (LHsSigWcType p) -- Signature can bind both -- kind and type vars -- ^ Pattern with a type signature - | SigPatOut (LPat id)+ | SigPatOut (LPat p) Type -- ^ Pattern with a type signature ------------ Pattern coercions (translation only) ---------------- | CoPat HsWrapper -- Coercion Pattern- -- If co :: t1 ~ t2, p :: t2,- -- then (CoPat co p) :: t1- (Pat id) -- Why not LPat? Ans: existing locn will do- Type -- Type of whole pattern, t1+ | CoPat HsWrapper -- Coercion Pattern+ -- If co :: t1 ~ t2, p :: t2,+ -- then (CoPat co p) :: t1+ (Pat p) -- Why not LPat? Ans: existing locn will do+ Type -- Type of whole pattern, t1 -- During desugaring a (CoPat co pat) turns into a cast with 'co' on -- the scrutinee, followed by a match on 'pat' -- ^ Coercion Pattern-deriving instance (DataId id) => Data (Pat id)+deriving instance (DataId p) => Data (Pat p) -- | Haskell Constructor Pattern Details-type HsConPatDetails id = HsConDetails (LPat id) (HsRecFields id (LPat id))+type HsConPatDetails p = HsConDetails (LPat p) (HsRecFields p (LPat p)) -hsConPatArgs :: HsConPatDetails id -> [LPat id]+hsConPatArgs :: HsConPatDetails p -> [LPat p] hsConPatArgs (PrefixCon ps) = ps hsConPatArgs (RecCon fs) = map (hsRecFieldArg . unLoc) (rec_flds fs) hsConPatArgs (InfixCon p1 p2) = [p1,p2]@@ -274,13 +279,13 @@ -- -- HsRecFields is used only for patterns and expressions (not data type -- declarations)-data HsRecFields id arg -- A bunch of record fields+data HsRecFields p arg -- A bunch of record fields -- { x = 3, y = True } -- Used for both expressions and patterns- = HsRecFields { rec_flds :: [LHsRecField id arg],+ = HsRecFields { rec_flds :: [LHsRecField p arg], rec_dotdot :: Maybe Int } -- Note [DotDot fields] deriving (Functor, Foldable, Traversable)-deriving instance (DataId id, Data arg) => Data (HsRecFields id arg)+deriving instance (DataId p, Data arg) => Data (HsRecFields p arg) -- Note [DotDot fields]@@ -298,19 +303,19 @@ -- and the remainder being 'filled in' implicitly -- | Located Haskell Record Field-type LHsRecField' id arg = Located (HsRecField' id arg)+type LHsRecField' p arg = Located (HsRecField' p arg) -- | Located Haskell Record Field-type LHsRecField id arg = Located (HsRecField id arg)+type LHsRecField p arg = Located (HsRecField p arg) -- | Located Haskell Record Update Field-type LHsRecUpdField id = Located (HsRecUpdField id)+type LHsRecUpdField p = Located (HsRecUpdField p) -- | Haskell Record Field-type HsRecField id arg = HsRecField' (FieldOcc id) arg+type HsRecField p arg = HsRecField' (FieldOcc p) arg -- | Haskell Record Update Field-type HsRecUpdField id = HsRecField' (AmbiguousFieldOcc id) (LHsExpr id)+type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p) -- | Haskell Record Field --@@ -378,26 +383,26 @@ -- -- See also Note [Disambiguating record fields] in TcExpr. -hsRecFields :: HsRecFields id arg -> [PostRn id id]+hsRecFields :: HsRecFields p arg -> [PostRn p (IdP p)] hsRecFields rbinds = map (unLoc . hsRecFieldSel . unLoc) (rec_flds rbinds) -- Probably won't typecheck at once, things have changed :/-hsRecFieldsArgs :: HsRecFields id arg -> [arg]+hsRecFieldsArgs :: HsRecFields p arg -> [arg] hsRecFieldsArgs rbinds = map (hsRecFieldArg . unLoc) (rec_flds rbinds) -hsRecFieldSel :: HsRecField name arg -> Located (PostRn name name)+hsRecFieldSel :: HsRecField pass arg -> Located (PostRn pass (IdP pass)) hsRecFieldSel = fmap selectorFieldOcc . hsRecFieldLbl -hsRecFieldId :: HsRecField Id arg -> Located Id+hsRecFieldId :: HsRecField GhcTc arg -> Located Id hsRecFieldId = hsRecFieldSel -hsRecUpdFieldRdr :: HsRecUpdField id -> Located RdrName+hsRecUpdFieldRdr :: HsRecUpdField p -> Located RdrName hsRecUpdFieldRdr = fmap rdrNameAmbiguousFieldOcc . hsRecFieldLbl -hsRecUpdFieldId :: HsRecField' (AmbiguousFieldOcc Id) arg -> Located Id+hsRecUpdFieldId :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> Located Id hsRecUpdFieldId = fmap selectorFieldOcc . hsRecUpdFieldOcc -hsRecUpdFieldOcc :: HsRecField' (AmbiguousFieldOcc Id) arg -> LFieldOcc Id+hsRecUpdFieldOcc :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> LFieldOcc GhcTc hsRecUpdFieldOcc = fmap unambiguousFieldOcc . hsRecFieldLbl @@ -409,7 +414,8 @@ ************************************************************************ -} -instance (OutputableBndrId name) => Outputable (Pat name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (Pat pass) where ppr = pprPat pprPatBndr :: OutputableBndr name => name -> SDoc@@ -421,10 +427,10 @@ else pprPrefixOcc var -pprParendLPat :: (OutputableBndrId name) => LPat name -> SDoc+pprParendLPat :: (SourceTextX pass, OutputableBndrId pass) => LPat pass -> SDoc pprParendLPat (L _ p) = pprParendPat p -pprParendPat :: (OutputableBndrId name) => Pat name -> SDoc+pprParendPat :: (SourceTextX pass, OutputableBndrId pass) => Pat pass -> SDoc pprParendPat p = sdocWithDynFlags $ \ dflags -> if need_parens dflags p then parens (pprPat p)@@ -438,7 +444,7 @@ -- But otherwise the CoPat is discarded, so it -- is the pattern inside that matters. Sigh. -pprPat :: (OutputableBndrId name) => Pat name -> SDoc+pprPat :: (SourceTextX pass, OutputableBndrId pass) => Pat pass -> SDoc pprPat (VarPat (L _ var)) = pprPatBndr var pprPat (WildPat _) = char '_' pprPat (LazyPat pat) = char '~' <> pprParendLPat pat@@ -475,27 +481,27 @@ else pprUserCon (unLoc con) details -pprUserCon :: (OutputableBndr con, OutputableBndrId id)- => con -> HsConPatDetails id -> SDoc+pprUserCon :: (SourceTextX p, OutputableBndr con, OutputableBndrId p)+ => con -> HsConPatDetails p -> SDoc pprUserCon c (InfixCon p1 p2) = ppr p1 <+> pprInfixOcc c <+> ppr p2 pprUserCon c details = pprPrefixOcc c <+> pprConArgs details -pprConArgs :: (OutputableBndrId id) => HsConPatDetails id -> SDoc+pprConArgs :: (SourceTextX p, OutputableBndrId p) => HsConPatDetails p -> SDoc pprConArgs (PrefixCon pats) = sep (map pprParendLPat pats) pprConArgs (InfixCon p1 p2) = sep [pprParendLPat p1, pprParendLPat p2] pprConArgs (RecCon rpats) = ppr rpats instance (Outputable arg)- => Outputable (HsRecFields id arg) where+ => Outputable (HsRecFields p arg) where ppr (HsRecFields { rec_flds = flds, rec_dotdot = Nothing }) = braces (fsep (punctuate comma (map ppr flds))) ppr (HsRecFields { rec_flds = flds, rec_dotdot = Just n }) = braces (fsep (punctuate comma (map ppr (take n flds) ++ [dotdot]))) where- dotdot = text ".." <+> ifPprDebug (ppr (drop n flds))+ dotdot = text ".." <+> whenPprDebug (ppr (drop n flds)) -instance (Outputable id, Outputable arg)- => Outputable (HsRecField' id arg) where+instance (Outputable p, Outputable arg)+ => Outputable (HsRecField' p arg) where ppr (HsRecField { hsRecFieldLbl = f, hsRecFieldArg = arg, hsRecPun = pun }) = ppr f <+> (ppUnless pun $ equals <+> ppr arg)@@ -509,19 +515,19 @@ ************************************************************************ -} -mkPrefixConPat :: DataCon -> [OutPat id] -> [Type] -> OutPat id+mkPrefixConPat :: DataCon -> [OutPat p] -> [Type] -> OutPat p -- Make a vanilla Prefix constructor pattern mkPrefixConPat dc pats tys = noLoc $ ConPatOut { pat_con = noLoc (RealDataCon dc), pat_tvs = [], pat_dicts = [], pat_binds = emptyTcEvBinds, pat_args = PrefixCon pats, pat_arg_tys = tys, pat_wrap = idHsWrapper } -mkNilPat :: Type -> OutPat id+mkNilPat :: Type -> OutPat p mkNilPat ty = mkPrefixConPat nilDataCon [] [ty] -mkCharLitPat :: SourceText -> Char -> OutPat id+mkCharLitPat :: (SourceTextX p) => SourceText -> Char -> OutPat p mkCharLitPat src c = mkPrefixConPat charDataCon- [noLoc $ LitPat (HsCharPrim src c)] []+ [noLoc $ LitPat (HsCharPrim (setSourceText src) c)] [] {- ************************************************************************@@ -555,16 +561,12 @@ The 1.3 report defines what ``irrefutable'' and ``failure-free'' patterns are. -} -isBangedPatBind :: HsBind id -> Bool-isBangedPatBind (PatBind {pat_lhs = pat}) = isBangedLPat pat-isBangedPatBind _ = False--isBangedLPat :: LPat id -> Bool+isBangedLPat :: LPat p -> Bool isBangedLPat (L _ (ParPat p)) = isBangedLPat p isBangedLPat (L _ (BangPat {})) = True isBangedLPat _ = False -looksLazyPatBind :: HsBind id -> Bool+looksLazyPatBind :: HsBind p -> Bool -- Returns True of anything *except* -- a StrictHsBind (as above) or -- a VarPat@@ -574,12 +576,10 @@ = looksLazyLPat p looksLazyPatBind (AbsBinds { abs_binds = binds }) = anyBag (looksLazyPatBind . unLoc) binds-looksLazyPatBind (AbsBindsSig { abs_sig_bind = L _ bind })- = looksLazyPatBind bind looksLazyPatBind _ = False -looksLazyLPat :: LPat id -> Bool+looksLazyLPat :: LPat p -> Bool looksLazyLPat (L _ (ParPat p)) = looksLazyLPat p looksLazyLPat (L _ (AsPat _ p)) = looksLazyLPat p looksLazyLPat (L _ (BangPat {})) = False@@ -587,7 +587,7 @@ looksLazyLPat (L _ (WildPat {})) = False looksLazyLPat _ = True -isIrrefutableHsPat :: (OutputableBndrId id) => LPat id -> Bool+isIrrefutableHsPat :: (SourceTextX p, OutputableBndrId p) => LPat p -> Bool -- (isIrrefutableHsPat p) is true if matching against p cannot fail, -- in the sense of falling through to the next pattern. -- (NB: this is not quite the same as the (silly) defn@@ -660,6 +660,8 @@ is the only thing that could possibly be matched! -} +-- | Returns 'True' if a pattern must be parenthesized in order to parse+-- (e.g., the @(x :: Int)@ in @f (x :: Int) = x@). hsPatNeedsParens :: Pat a -> Bool hsPatNeedsParens (NPlusKPat {}) = True hsPatNeedsParens (SplicePat {}) = False@@ -682,23 +684,75 @@ hsPatNeedsParens (LitPat {}) = False hsPatNeedsParens (NPat {}) = False +-- | Returns 'True' if a constructor pattern must be parenthesized in order+-- to parse. conPatNeedsParens :: HsConDetails a b -> Bool conPatNeedsParens (PrefixCon {}) = False conPatNeedsParens (InfixCon {}) = True conPatNeedsParens (RecCon {}) = False +-- | Returns 'True' for compound patterns that need parentheses when used in+-- an argument position.+--+-- Note that this is different from 'hsPatNeedsParens', which only says if+-- a pattern needs to be parenthesized to parse in /any/ position, whereas+-- 'isCompountPat' says if a pattern needs to be parenthesized in an /argument/+-- position. In other words, @'hsPatNeedsParens' x@ implies+-- @'isCompoundPat' x@, but not necessarily the other way around.+isCompoundPat :: Pat a -> Bool+isCompoundPat (NPlusKPat {}) = True+isCompoundPat (SplicePat {}) = False+isCompoundPat (ConPatIn _ ds) = isCompoundConPat ds+isCompoundPat p@(ConPatOut {}) = isCompoundConPat (pat_args p)+isCompoundPat (SigPatIn {}) = True+isCompoundPat (SigPatOut {}) = True+isCompoundPat (ViewPat {}) = True+isCompoundPat (CoPat _ p _) = isCompoundPat p+isCompoundPat (WildPat {}) = False+isCompoundPat (VarPat {}) = False+isCompoundPat (LazyPat {}) = False+isCompoundPat (BangPat {}) = False+isCompoundPat (ParPat {}) = False+isCompoundPat (AsPat {}) = False+isCompoundPat (TuplePat {}) = False+isCompoundPat (SumPat {}) = False+isCompoundPat (ListPat {}) = False+isCompoundPat (PArrPat {}) = False+isCompoundPat (LitPat p) = isCompoundHsLit p+isCompoundPat (NPat (L _ p) _ _ _) = isCompoundHsOverLit p++-- | Returns 'True' for compound constructor patterns that need parentheses+-- when used in an argument position.+--+-- Note that this is different from 'conPatNeedsParens', which only says if+-- a constructor pattern needs to be parenthesized to parse in /any/ position,+-- whereas 'isCompountConPat' says if a pattern needs to be parenthesized in an+-- /argument/ position. In other words, @'conPatNeedsParens' x@ implies+-- @'isCompoundConPat' x@, but not necessarily the other way around.+isCompoundConPat :: HsConDetails a b -> Bool+isCompoundConPat (PrefixCon args) = not (null args)+isCompoundConPat (InfixCon {}) = True+isCompoundConPat (RecCon {}) = False++-- | @'parenthesizeCompoundPat' p@ checks if @'isCompoundPat' p@ is true, and+-- if so, surrounds @p@ with a 'ParPat'. Otherwise, it simply returns @p@.+parenthesizeCompoundPat :: LPat p -> LPat p+parenthesizeCompoundPat lp@(L loc p)+ | isCompoundPat p = L loc (ParPat lp)+ | otherwise = lp+ {- % Collect all EvVars from all constructor patterns -} -- May need to add more cases-collectEvVarsPats :: [Pat id] -> Bag EvVar+collectEvVarsPats :: [Pat p] -> Bag EvVar collectEvVarsPats = unionManyBags . map collectEvVarsPat -collectEvVarsLPat :: LPat id -> Bag EvVar+collectEvVarsLPat :: LPat p -> Bag EvVar collectEvVarsLPat (L _ pat) = collectEvVarsPat pat -collectEvVarsPat :: Pat id -> Bag EvVar+collectEvVarsPat :: Pat p -> Bag EvVar collectEvVarsPat pat = case pat of LazyPat p -> collectEvVarsLPat p
hsSyn/HsPat.hs-boot view
@@ -10,11 +10,11 @@ import Data.Data hiding (Fixity) import Outputable-import PlaceHolder ( DataId, OutputableBndrId )+import HsExtension ( SourceTextX, DataId, OutputableBndrId ) type role Pat nominal data Pat (i :: *) type LPat i = Located (Pat i) -instance (DataId id) => Data (Pat id)-instance (OutputableBndrId name) => Outputable (Pat name)+instance (DataId p) => Data (Pat p)+instance (SourceTextX pass, OutputableBndrId pass) => Outputable (Pat pass)
hsSyn/HsSyn.hs view
@@ -27,24 +27,27 @@ module HsUtils, module HsDoc, module PlaceHolder,+ module HsExtension, Fixity, HsModule(..) ) where -- friends:+import GhcPrelude+ import HsDecls import HsBinds import HsExpr import HsImpExp import HsLit import PlaceHolder+import HsExtension import HsPat import HsTypes import BasicTypes ( Fixity, WarningTxt ) import HsUtils import HsDoc-import OccName ( HasOccName(..) ) -- others: import Outputable@@ -109,8 +112,8 @@ -- For details on above see note [Api annotations] in ApiAnnotation deriving instance (DataId name) => Data (HsModule name) -instance (OutputableBndrId name, HasOccName name)- => Outputable (HsModule name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsModule pass) where ppr (HsModule Nothing _ imports decls _ mbDoc) = pp_mb mbDoc $$ pp_nonnull imports
hsSyn/HsTypes.hs view
@@ -64,14 +64,17 @@ hsLTyVarBndrToType, hsLTyVarBndrsToTypes, -- Printing- pprParendHsType, pprHsForAll, pprHsForAllTvs, pprHsForAllExtra,- pprHsContext, pprHsContextNoArrow, pprHsContextMaybe+ pprHsType, pprHsForAll, pprHsForAllTvs, pprHsForAllExtra,+ pprHsContext, pprHsContextNoArrow, pprHsContextMaybe,+ isCompoundHsType, parenthesizeCompoundHsType ) where +import GhcPrelude+ import {-# SOURCE #-} HsExpr ( HsSplice, pprSplice ) -import PlaceHolder ( PostTc,PostRn,DataId,PlaceHolder(..),- OutputableBndrId )+import PlaceHolder ( PlaceHolder(..) )+import HsExtension import Id ( Id ) import Name( Name )@@ -101,10 +104,10 @@ -} -- | Located Bang Type-type LBangType name = Located (BangType name)+type LBangType pass = Located (BangType pass) -- | Bang Type-type BangType name = HsType name -- Bangs are in the HsType data type+type BangType pass = HsType pass -- Bangs are in the HsType data type getBangType :: LHsType a -> LHsType a getBangType (L _ (HsBangTy _ ty)) = ty@@ -219,26 +222,26 @@ -} -- | Located Haskell Context-type LHsContext name = Located (HsContext name)+type LHsContext pass = Located (HsContext pass) -- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnUnit' -- For details on above see note [Api annotations] in ApiAnnotation -- | Haskell Context-type HsContext name = [LHsType name]+type HsContext pass = [LHsType pass] -- | Located Haskell Type-type LHsType name = Located (HsType name)+type LHsType pass = Located (HsType pass) -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when -- in a list -- For details on above see note [Api annotations] in ApiAnnotation -- | Haskell Kind-type HsKind name = HsType name+type HsKind pass = HsType pass -- | Located Haskell Kind-type LHsKind name = Located (HsKind name)+type LHsKind pass = Located (HsKind pass) -- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -- For details on above see note [Api annotations] in ApiAnnotation@@ -248,58 +251,62 @@ -- The explicitly-quantified binders in a data/type declaration -- | Located Haskell Type Variable Binder-type LHsTyVarBndr name = Located (HsTyVarBndr name)+type LHsTyVarBndr pass = Located (HsTyVarBndr pass) -- See Note [HsType binders] -- | Located Haskell Quantified Type Variables-data LHsQTyVars name -- See Note [HsType binders]- = HsQTvs { hsq_implicit :: PostRn name [Name] -- implicit (dependent) variables- , hsq_explicit :: [LHsTyVarBndr name] -- explicit variables- -- See Note [HsForAllTy tyvar binders]- , hsq_dependent :: PostRn name NameSet- -- which explicit vars are dependent+data LHsQTyVars pass -- See Note [HsType binders]+ = HsQTvs { hsq_implicit :: PostRn pass [Name]+ -- Implicit (dependent) variables++ , hsq_explicit :: [LHsTyVarBndr pass]+ -- Explicit variables, written by the user+ -- See Note [HsForAllTy tyvar binders]++ , hsq_dependent :: PostRn pass NameSet+ -- Which members of hsq_explicit are dependent; that is,+ -- mentioned in the kind of a later hsq_explicit,+ -- or mentioned in a kind in the scope of this HsQTvs -- See Note [Dependent LHsQTyVars] in TcHsType } -deriving instance (DataId name) => Data (LHsQTyVars name)+deriving instance (DataId pass) => Data (LHsQTyVars pass) -mkHsQTvs :: [LHsTyVarBndr RdrName] -> LHsQTyVars RdrName+mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs mkHsQTvs tvs = HsQTvs { hsq_implicit = PlaceHolder, hsq_explicit = tvs , hsq_dependent = PlaceHolder } -hsQTvExplicit :: LHsQTyVars name -> [LHsTyVarBndr name]+hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass] hsQTvExplicit = hsq_explicit -emptyLHsQTvs :: LHsQTyVars Name+emptyLHsQTvs :: LHsQTyVars GhcRn emptyLHsQTvs = HsQTvs [] [] emptyNameSet -isEmptyLHsQTvs :: LHsQTyVars Name -> Bool+isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool isEmptyLHsQTvs (HsQTvs [] [] _) = True isEmptyLHsQTvs _ = False ------------------------------------------------ -- HsImplicitBndrs--- Used to quantify the binders of a type in cases--- when a HsForAll isn't appropriate:+-- Used to quantify the implicit binders of a type+-- * Implicit binders of a type signature (LHsSigType/LHsSigWcType) -- * Patterns in a type/data family instance (HsTyPats)--- * Type of a rule binder (RuleBndr)--- * Pattern type signatures (SigPatIn)--- In the last of these, wildcards can happen, so we must accommodate them -- | Haskell Implicit Binders-data HsImplicitBndrs name thing -- See Note [HsType binders]- = HsIB { hsib_vars :: PostRn name [Name] -- Implicitly-bound kind & type vars+data HsImplicitBndrs pass thing -- See Note [HsType binders]+ = HsIB { hsib_vars :: PostRn pass [Name] -- Implicitly-bound kind & type vars , hsib_body :: thing -- Main payload (type or list of types)- , hsib_closed :: PostRn name Bool -- Taking the hsib_vars into account,+ , hsib_closed :: PostRn pass Bool -- Taking the hsib_vars into account, -- is the payload closed? Used in -- TcHsType.decideKindGeneralisationPlan }+deriving instance (DataId pass, Data thing) => Data (HsImplicitBndrs pass thing) -- | Haskell Wildcard Binders-data HsWildCardBndrs name thing+data HsWildCardBndrs pass thing -- See Note [HsType binders] -- See Note [The wildcard story for types]- = HsWC { hswc_wcs :: PostRn name [Name]+ = HsWC { hswc_wcs :: PostRn pass [Name] -- Wild cards, both named and anonymous -- after the renamer @@ -309,33 +316,29 @@ -- it's still there in the hsc_body. } -deriving instance (Data name, Data thing, Data (PostRn name [Name]), Data (PostRn name Bool))- => Data (HsImplicitBndrs name thing)--deriving instance (Data name, Data thing, Data (PostRn name [Name]))- => Data (HsWildCardBndrs name thing)+deriving instance (DataId pass, Data thing) => Data (HsWildCardBndrs pass thing) -- | Located Haskell Signature Type-type LHsSigType name = HsImplicitBndrs name (LHsType name) -- Implicit only+type LHsSigType pass = HsImplicitBndrs pass (LHsType pass) -- Implicit only -- | Located Haskell Wildcard Type-type LHsWcType name = HsWildCardBndrs name (LHsType name) -- Wildcard only+type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) -- Wildcard only -- | Located Haskell Signature Wildcard Type-type LHsSigWcType name = HsWildCardBndrs name (LHsSigType name) -- Both+type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) -- Both -- See Note [Representing type signatures] -hsImplicitBody :: HsImplicitBndrs name thing -> thing+hsImplicitBody :: HsImplicitBndrs pass thing -> thing hsImplicitBody (HsIB { hsib_body = body }) = body -hsSigType :: LHsSigType name -> LHsType name+hsSigType :: LHsSigType pass -> LHsType pass hsSigType = hsImplicitBody -hsSigWcType :: LHsSigWcType name -> LHsType name+hsSigWcType :: LHsSigWcType pass -> LHsType pass hsSigWcType sig_ty = hsib_body (hswc_body sig_ty) -dropWildCards :: LHsSigWcType name -> LHsSigType name+dropWildCards :: LHsSigWcType pass -> LHsSigType pass -- Drop the wildcard part of a LHsSigWcType dropWildCards sig_ty = hswc_body sig_ty @@ -359,23 +362,23 @@ the explicitly forall'd tyvar 'a' is bound by the HsForAllTy -} -mkHsImplicitBndrs :: thing -> HsImplicitBndrs RdrName thing+mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing mkHsImplicitBndrs x = HsIB { hsib_body = x , hsib_vars = PlaceHolder , hsib_closed = PlaceHolder } -mkHsWildCardBndrs :: thing -> HsWildCardBndrs RdrName thing+mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing mkHsWildCardBndrs x = HsWC { hswc_body = x , hswc_wcs = PlaceHolder } -- Add empty binders. This is a bit suspicious; what if -- the wrapped thing had free type variables?-mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs Name thing+mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs GhcRn thing mkEmptyImplicitBndrs x = HsIB { hsib_body = x , hsib_vars = [] , hsib_closed = False } -mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs Name thing+mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing mkEmptyWildCardBndrs x = HsWC { hswc_body = x , hswc_wcs = [] } @@ -400,46 +403,47 @@ -------------------------------------------------- -- | Haskell Type Variable Binder-data HsTyVarBndr name+data HsTyVarBndr pass = UserTyVar -- no explicit kinding- (Located name)+ (Located (IdP pass)) -- See Note [Located RdrNames] in HsExpr | KindedTyVar- (Located name)- (LHsKind name) -- The user-supplied kind signature+ (Located (IdP pass))+ (LHsKind pass) -- The user-supplied kind signature -- ^ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', -- 'ApiAnnotation.AnnDcolon', 'ApiAnnotation.AnnClose' -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (HsTyVarBndr name)+deriving instance (DataId pass) => Data (HsTyVarBndr pass) -- | Does this 'HsTyVarBndr' come with an explicit kind annotation?-isHsKindedTyVar :: HsTyVarBndr name -> Bool+isHsKindedTyVar :: HsTyVarBndr pass -> Bool isHsKindedTyVar (UserTyVar {}) = False isHsKindedTyVar (KindedTyVar {}) = True -- | Do all type variables in this 'LHsQTyVars' come with kind annotations?-hsTvbAllKinded :: LHsQTyVars name -> Bool+hsTvbAllKinded :: LHsQTyVars pass -> Bool hsTvbAllKinded = all (isHsKindedTyVar . unLoc) . hsQTvExplicit -- | Haskell Type-data HsType name+data HsType pass = HsForAllTy -- See Note [HsType binders]- { hst_bndrs :: [LHsTyVarBndr name] -- Explicit, user-supplied 'forall a b c'- , hst_body :: LHsType name -- body type+ { hst_bndrs :: [LHsTyVarBndr pass]+ -- Explicit, user-supplied 'forall a b c'+ , hst_body :: LHsType pass -- body type } -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnForall', -- 'ApiAnnotation.AnnDot','ApiAnnotation.AnnDarrow' -- For details on above see note [Api annotations] in ApiAnnotation | HsQualTy -- See Note [HsType binders]- { hst_ctxt :: LHsContext name -- Context C => blah- , hst_body :: LHsType name }+ { hst_ctxt :: LHsContext pass -- Context C => blah+ , hst_body :: LHsType pass } | HsTyVar Promoted -- whether explicitly promoted, for the pretty -- printer- (Located name)+ (Located (IdP pass)) -- Type variable, type constructor, or data constructor -- see Note [Promotions (HsTyVar)] -- See Note [Located RdrNames] in HsExpr@@ -447,53 +451,53 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsAppsTy [LHsAppType name] -- Used only before renaming,+ | HsAppsTy [LHsAppType pass] -- Used only before renaming, -- Note [HsAppsTy] -- ^ - 'ApiAnnotation.AnnKeywordId' : None - | HsAppTy (LHsType name)- (LHsType name)+ | HsAppTy (LHsType pass)+ (LHsType pass) -- ^ - 'ApiAnnotation.AnnKeywordId' : None -- For details on above see note [Api annotations] in ApiAnnotation - | HsFunTy (LHsType name) -- function type- (LHsType name)+ | HsFunTy (LHsType pass) -- function type+ (LHsType pass) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow', -- For details on above see note [Api annotations] in ApiAnnotation - | HsListTy (LHsType name) -- Element type+ | HsListTy (LHsType pass) -- Element type -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'['@, -- 'ApiAnnotation.AnnClose' @']'@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsPArrTy (LHsType name) -- Elem. type of parallel array: [:t:]+ | HsPArrTy (LHsType pass) -- Elem. type of parallel array: [:t:] -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'[:'@, -- 'ApiAnnotation.AnnClose' @':]'@ -- For details on above see note [Api annotations] in ApiAnnotation | HsTupleTy HsTupleSort- [LHsType name] -- Element types (length gives arity)+ [LHsType pass] -- Element types (length gives arity) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'(' or '(#'@, -- 'ApiAnnotation.AnnClose' @')' or '#)'@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsSumTy [LHsType name] -- Element types (length gives arity)+ | HsSumTy [LHsType pass] -- Element types (length gives arity) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'(#'@, -- 'ApiAnnotation.AnnClose' '#)'@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsOpTy (LHsType name) (Located name) (LHsType name)+ | HsOpTy (LHsType pass) (Located (IdP pass)) (LHsType pass) -- ^ - 'ApiAnnotation.AnnKeywordId' : None -- For details on above see note [Api annotations] in ApiAnnotation - | HsParTy (LHsType name) -- See Note [Parens in HsSyn] in HsExpr+ | HsParTy (LHsType pass) -- See Note [Parens in HsSyn] in HsExpr -- Parenthesis preserved for the precedence re-arrangement in RnTypes -- It's important that a * (b + c) doesn't get rearranged to (a*b) + c! -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,@@ -502,7 +506,8 @@ -- For details on above see note [Api annotations] in ApiAnnotation | HsIParamTy (Located HsIPName) -- (?x :: ty)- (LHsType name) -- Implicit parameters as they occur in contexts+ (LHsType pass) -- Implicit parameters as they occur in+ -- contexts -- ^ -- > (?x :: ty) --@@ -510,8 +515,10 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsEqTy (LHsType name) -- ty1 ~ ty2- (LHsType name) -- Always allowed even without TypeOperators, and has special kinding rule+ | HsEqTy (LHsType pass) -- ty1 ~ ty2+ (LHsType pass) -- Always allowed even without+ -- TypeOperators, and has special+ -- kinding rule -- ^ -- > ty1 ~ ty2 --@@ -519,8 +526,8 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsKindSig (LHsType name) -- (ty :: kind)- (LHsKind name) -- A type with a kind signature+ | HsKindSig (LHsType pass) -- (ty :: kind)+ (LHsKind pass) -- A type with a kind signature -- ^ -- > (ty :: kind) --@@ -529,19 +536,19 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsSpliceTy (HsSplice name) -- Includes quasi-quotes- (PostTc name Kind)+ | HsSpliceTy (HsSplice pass) -- Includes quasi-quotes+ (PostTc pass Kind) -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'$('@, -- 'ApiAnnotation.AnnClose' @')'@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsDocTy (LHsType name) LHsDocString -- A documented type+ | HsDocTy (LHsType pass) LHsDocString -- A documented type -- ^ - 'ApiAnnotation.AnnKeywordId' : None -- For details on above see note [Api annotations] in ApiAnnotation - | HsBangTy HsSrcBang (LHsType name) -- Bang-style type annotations+ | HsBangTy HsSrcBang (LHsType pass) -- Bang-style type annotations -- ^ - 'ApiAnnotation.AnnKeywordId' : -- 'ApiAnnotation.AnnOpen' @'{-\# UNPACK' or '{-\# NOUNPACK'@, -- 'ApiAnnotation.AnnClose' @'#-}'@@@ -549,7 +556,7 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsRecTy [LConDeclField name] -- Only in data type declarations+ | HsRecTy [LConDeclField pass] -- Only in data type declarations -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{'@, -- 'ApiAnnotation.AnnClose' @'}'@ @@ -563,16 +570,16 @@ | HsExplicitListTy -- A promoted explicit list Promoted -- whether explcitly promoted, for pretty printer- (PostTc name Kind) -- See Note [Promoted lists and tuples]- [LHsType name]+ (PostTc pass Kind) -- See Note [Promoted lists and tuples]+ [LHsType pass] -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @"'["@, -- 'ApiAnnotation.AnnClose' @']'@ -- For details on above see note [Api annotations] in ApiAnnotation | HsExplicitTupleTy -- A promoted explicit tuple- [PostTc name Kind] -- See Note [Promoted lists and tuples]- [LHsType name]+ [PostTc pass Kind] -- See Note [Promoted lists and tuples]+ [LHsType pass] -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @"'("@, -- 'ApiAnnotation.AnnClose' @')'@ @@ -583,12 +590,12 @@ -- For details on above see note [Api annotations] in ApiAnnotation - | HsWildCardTy (HsWildCardInfo name) -- A type wildcard+ | HsWildCardTy (HsWildCardInfo pass) -- A type wildcard -- See Note [The wildcard story for types] -- ^ - 'ApiAnnotation.AnnKeywordId' : None -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (HsType name)+deriving instance (DataId pass) => Data (HsType pass) -- Note [Literal source text] in BasicTypes for SourceText fields in -- the following@@ -598,24 +605,25 @@ | HsStrTy SourceText FastString deriving Data -newtype HsWildCardInfo name -- See Note [The wildcard story for types]- = AnonWildCard (PostRn name (Located Name))+newtype HsWildCardInfo pass -- See Note [The wildcard story for types]+ = AnonWildCard (PostRn pass (Located Name)) -- A anonymous wild card ('_'). A fresh Name is generated for -- each individual anonymous wildcard during renaming-deriving instance (DataId name) => Data (HsWildCardInfo name)+deriving instance (DataId pass) => Data (HsWildCardInfo pass) -- | Located Haskell Application Type-type LHsAppType name = Located (HsAppType name)+type LHsAppType pass = Located (HsAppType pass) -- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSimpleQuote' -- | Haskell Application Type-data HsAppType name- = HsAppInfix (Located name) -- either a symbol or an id in backticks- | HsAppPrefix (LHsType name) -- anything else, including things like (+)-deriving instance (DataId name) => Data (HsAppType name)+data HsAppType pass+ = HsAppInfix (Located (IdP pass)) -- either a symbol or an id in backticks+ | HsAppPrefix (LHsType pass) -- anything else, including things like (+)+deriving instance (DataId pass) => Data (HsAppType pass) -instance (OutputableBndrId name) => Outputable (HsAppType name) where- ppr = ppr_app_ty TopPrec+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsAppType pass) where+ ppr = ppr_app_ty {- Note [HsForAllTy tyvar binders]@@ -741,24 +749,25 @@ deriving (Data, Eq, Show) -- | Located Constructor Declaration Field-type LConDeclField name = Located (ConDeclField name)+type LConDeclField pass = Located (ConDeclField pass) -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when -- in a list -- For details on above see note [Api annotations] in ApiAnnotation -- | Constructor Declaration Field-data ConDeclField name -- Record fields have Haddoc docs on them- = ConDeclField { cd_fld_names :: [LFieldOcc name],- -- ^ See Note [ConDeclField names]- cd_fld_type :: LBangType name,+data ConDeclField pass -- Record fields have Haddoc docs on them+ = ConDeclField { cd_fld_names :: [LFieldOcc pass],+ -- ^ See Note [ConDeclField passs]+ cd_fld_type :: LBangType pass, cd_fld_doc :: Maybe LHsDocString } -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -- For details on above see note [Api annotations] in ApiAnnotation-deriving instance (DataId name) => Data (ConDeclField name)+deriving instance (DataId pass) => Data (ConDeclField pass) -instance (OutputableBndrId name) => Outputable (ConDeclField name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (ConDeclField pass) where ppr (ConDeclField fld_n fld_ty _) = ppr fld_n <+> dcolon <+> ppr fld_ty -- HsConDetails is used for patterns/expressions *and* for data type@@ -783,11 +792,11 @@ :: (Monad m) => (SDoc -> m ()) -> SDoc- -> HsConDetails (LHsType Name) (Located [LConDeclField Name])+ -> HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]) -- ^ Original details- -> LHsType Name -- ^ Original result type- -> m (HsConDetails (LHsType Name) (Located [LConDeclField Name]),- LHsType Name)+ -> LHsType GhcRn -- ^ Original result type+ -> m (HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]),+ LHsType GhcRn) updateGadtResult failWith doc details ty = do { let (arg_tys, res_ty) = splitHsFunType ty badConSig = text "Malformed constructor signature"@@ -801,7 +810,7 @@ PrefixCon {} -> return (PrefixCon arg_tys, res_ty)} {--Note [ConDeclField names]+Note [ConDeclField passs] ~~~~~~~~~~~~~~~~~~~~~~~~~ A ConDeclField contains a list of field occurrences: these always@@ -825,7 +834,7 @@ -- types ----------------------hsWcScopedTvs :: LHsSigWcType Name -> [Name]+hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name] -- Get the lexically-scoped type variables of a HsSigType -- - the explicitly-given forall'd type variables -- - the implicitly-bound kind variables@@ -841,7 +850,7 @@ -- (this is consistent with GHC 7 behaviour) _ -> nwcs -hsScopedTvs :: LHsSigType Name -> [Name]+hsScopedTvs :: LHsSigType GhcRn -> [Name] -- Same as hsWcScopedTvs, but for a LHsSigType hsScopedTvs sig_ty | HsIB { hsib_vars = vars, hsib_body = sig_ty2 } <- sig_ty@@ -864,30 +873,30 @@ -} ----------------------hsTyVarName :: HsTyVarBndr name -> name+hsTyVarName :: HsTyVarBndr pass -> IdP pass hsTyVarName (UserTyVar (L _ n)) = n hsTyVarName (KindedTyVar (L _ n) _) = n -hsLTyVarName :: LHsTyVarBndr name -> name+hsLTyVarName :: LHsTyVarBndr pass -> IdP pass hsLTyVarName = hsTyVarName . unLoc -hsExplicitLTyVarNames :: LHsQTyVars name -> [name]+hsExplicitLTyVarNames :: LHsQTyVars pass -> [IdP pass] -- Explicit variables only hsExplicitLTyVarNames qtvs = map hsLTyVarName (hsQTvExplicit qtvs) -hsAllLTyVarNames :: LHsQTyVars Name -> [Name]+hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name] -- All variables hsAllLTyVarNames (HsQTvs { hsq_implicit = kvs, hsq_explicit = tvs }) = kvs ++ map hsLTyVarName tvs -hsLTyVarLocName :: LHsTyVarBndr name -> Located name+hsLTyVarLocName :: LHsTyVarBndr pass -> Located (IdP pass) hsLTyVarLocName = fmap hsTyVarName -hsLTyVarLocNames :: LHsQTyVars name -> [Located name]+hsLTyVarLocNames :: LHsQTyVars pass -> [Located (IdP pass)] hsLTyVarLocNames qtvs = map hsLTyVarLocName (hsQTvExplicit qtvs) -- | Convert a LHsTyVarBndr to an equivalent LHsType.-hsLTyVarBndrToType :: LHsTyVarBndr name -> LHsType name+hsLTyVarBndrToType :: LHsTyVarBndr pass -> LHsType pass hsLTyVarBndrToType = fmap cvt where cvt (UserTyVar n) = HsTyVar NotPromoted n cvt (KindedTyVar (L name_loc n) kind)@@ -895,19 +904,19 @@ -- | Convert a LHsTyVarBndrs to a list of types. -- Works on *type* variable only, no kind vars.-hsLTyVarBndrsToTypes :: LHsQTyVars name -> [LHsType name]+hsLTyVarBndrsToTypes :: LHsQTyVars pass -> [LHsType pass] hsLTyVarBndrsToTypes (HsQTvs { hsq_explicit = tvbs }) = map hsLTyVarBndrToType tvbs ----------------------wildCardName :: HsWildCardInfo Name -> Name+wildCardName :: HsWildCardInfo GhcRn -> Name wildCardName (AnonWildCard (L _ n)) = n -- Two wild cards are the same when they have the same location-sameWildCard :: Located (HsWildCardInfo name)- -> Located (HsWildCardInfo name) -> Bool+sameWildCard :: Located (HsWildCardInfo pass)+ -> Located (HsWildCardInfo pass) -> Bool sameWildCard (L l1 (AnonWildCard _)) (L l2 (AnonWildCard _)) = l1 == l2 -ignoreParens :: LHsType name -> LHsType name+ignoreParens :: LHsType pass -> LHsType pass ignoreParens (L _ (HsParTy ty)) = ignoreParens ty ignoreParens (L _ (HsAppsTy [L _ (HsAppPrefix ty)])) = ignoreParens ty ignoreParens ty = ty@@ -920,16 +929,16 @@ ************************************************************************ -} -mkAnonWildCardTy :: HsType RdrName+mkAnonWildCardTy :: HsType GhcPs mkAnonWildCardTy = HsWildCardTy (AnonWildCard PlaceHolder) -mkHsOpTy :: LHsType name -> Located name -> LHsType name -> HsType name+mkHsOpTy :: LHsType pass -> Located (IdP pass) -> LHsType pass -> HsType pass mkHsOpTy ty1 op ty2 = HsOpTy ty1 op ty2 -mkHsAppTy :: LHsType name -> LHsType name -> LHsType name-mkHsAppTy t1 t2 = addCLoc t1 t2 (HsAppTy t1 t2)+mkHsAppTy :: LHsType pass -> LHsType pass -> LHsType pass+mkHsAppTy t1 t2 = addCLoc t1 t2 (HsAppTy t1 (parenthesizeCompoundHsType t2)) -mkHsAppTys :: LHsType name -> [LHsType name] -> LHsType name+mkHsAppTys :: LHsType pass -> [LHsType pass] -> LHsType pass mkHsAppTys = foldl mkHsAppTy @@ -947,7 +956,7 @@ -- splitHsFunType (a -> (b -> c)) = ([a,b], c) -- Also deals with (->) t1 t2; that is why it only works on LHsType Name -- (see Trac #9096)-splitHsFunType :: LHsType Name -> ([LHsType Name], LHsType Name)+splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn) splitHsFunType (L _ (HsParTy ty)) = splitHsFunType ty @@ -971,8 +980,8 @@ -------------------------------- -- | Retrieves the head of an HsAppsTy, if this can be done unambiguously, -- without consulting fixities.-getAppsTyHead_maybe :: [LHsAppType name]- -> Maybe (LHsType name, [LHsType name], LexicalFixity)+getAppsTyHead_maybe :: [LHsAppType pass]+ -> Maybe (LHsType pass, [LHsType pass], LexicalFixity) getAppsTyHead_maybe tys = case splitHsAppsTy tys of ([app1:apps], []) -> -- no symbols, some normal types Just (mkHsAppTys app1 apps, [], Prefix)@@ -982,13 +991,13 @@ _ -> -- can't figure it out Nothing --- | Splits a [HsAppType name] (the payload of an HsAppsTy) into regions of prefix--- types (normal types) and infix operators.+-- | Splits a [HsAppType pass] (the payload of an HsAppsTy) into regions of+-- prefix types (normal types) and infix operators. -- If @splitHsAppsTy tys = (non_syms, syms)@, then @tys@ starts with the first -- element of @non_syms@ followed by the first element of @syms@ followed by -- the next element of @non_syms@, etc. It is guaranteed that the non_syms list -- has one more element than the syms list.-splitHsAppsTy :: [LHsAppType name] -> ([[LHsType name]], [Located name])+splitHsAppsTy :: [LHsAppType pass] -> ([[LHsType pass]], [Located (IdP pass)]) splitHsAppsTy = go [] [] [] where go acc acc_non acc_sym [] = (reverse (reverse acc : acc_non), reverse acc_sym)@@ -1001,7 +1010,8 @@ -- somewhat like splitHsAppTys, but a little more thorough -- used to examine the result of a GADT-like datacon, so it doesn't handle -- *all* cases (like lists, tuples, (~), etc.)-hsTyGetAppHead_maybe :: LHsType name -> Maybe (Located name, [LHsType name])+hsTyGetAppHead_maybe :: LHsType pass+ -> Maybe (Located (IdP pass), [LHsType pass]) hsTyGetAppHead_maybe = go [] where go tys (L _ (HsTyVar _ ln)) = Just (ln, tys)@@ -1014,19 +1024,20 @@ go tys (L _ (HsKindSig t _)) = go tys t go _ _ = Nothing -splitHsAppTys :: LHsType Name -> [LHsType Name] -> (LHsType Name, [LHsType Name])+splitHsAppTys :: LHsType GhcRn -> [LHsType GhcRn]+ -> (LHsType GhcRn, [LHsType GhcRn]) -- no need to worry about HsAppsTy here splitHsAppTys (L _ (HsAppTy f a)) as = splitHsAppTys f (a:as) splitHsAppTys (L _ (HsParTy f)) as = splitHsAppTys f as splitHsAppTys f as = (f,as) ---------------------------------splitLHsPatSynTy :: LHsType name- -> ( [LHsTyVarBndr name] -- universals- , LHsContext name -- required constraints- , [LHsTyVarBndr name] -- existentials- , LHsContext name -- provided constraints- , LHsType name) -- body type+splitLHsPatSynTy :: LHsType pass+ -> ( [LHsTyVarBndr pass] -- universals+ , LHsContext pass -- required constraints+ , [LHsTyVarBndr pass] -- existentials+ , LHsContext pass -- provided constraints+ , LHsType pass) -- body type splitLHsPatSynTy ty = (univs, reqs, exis, provs, ty4) where (univs, ty1) = splitLHsForAllTy ty@@ -1034,22 +1045,25 @@ (exis, ty3) = splitLHsForAllTy ty2 (provs, ty4) = splitLHsQualTy ty3 -splitLHsSigmaTy :: LHsType name -> ([LHsTyVarBndr name], LHsContext name, LHsType name)+splitLHsSigmaTy :: LHsType pass+ -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass) splitLHsSigmaTy ty | (tvs, ty1) <- splitLHsForAllTy ty , (ctxt, ty2) <- splitLHsQualTy ty1 = (tvs, ctxt, ty2) -splitLHsForAllTy :: LHsType name -> ([LHsTyVarBndr name], LHsType name)+splitLHsForAllTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass) splitLHsForAllTy (L _ (HsForAllTy { hst_bndrs = tvs, hst_body = body })) = (tvs, body)-splitLHsForAllTy body = ([], body)+splitLHsForAllTy (L _ (HsParTy t)) = splitLHsForAllTy t+splitLHsForAllTy body = ([], body) -splitLHsQualTy :: LHsType name -> (LHsContext name, LHsType name)+splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass) splitLHsQualTy (L _ (HsQualTy { hst_ctxt = ctxt, hst_body = body })) = (ctxt, body)-splitLHsQualTy body = (noLoc [], body)+splitLHsQualTy (L _ (HsParTy t)) = splitLHsQualTy t+splitLHsQualTy body = (noLoc [], body) -splitLHsInstDeclTy :: LHsSigType Name- -> ([Name], LHsContext Name, LHsType Name)+splitLHsInstDeclTy :: LHsSigType GhcRn+ -> ([Name], LHsContext GhcRn, LHsType GhcRn) -- Split up an instance decl type, returning the pieces splitLHsInstDeclTy (HsIB { hsib_vars = itkvs , hsib_body = inst_ty })@@ -1058,12 +1072,12 @@ -- Return implicitly bound type and kind vars -- For an instance decl, all of them are in scope -getLHsInstDeclHead :: LHsSigType name -> LHsType name+getLHsInstDeclHead :: LHsSigType pass -> LHsType pass getLHsInstDeclHead inst_ty | (_tvs, _cxt, body_ty) <- splitLHsSigmaTy (hsSigType inst_ty) = body_ty -getLHsInstDeclClass_maybe :: LHsSigType name -> Maybe (Located name)+getLHsInstDeclClass_maybe :: LHsSigType pass -> Maybe (Located (IdP pass)) -- Works on (HsSigType RdrName) getLHsInstDeclClass_maybe inst_ty = do { let head_ty = getLHsInstDeclHead inst_ty@@ -1079,25 +1093,25 @@ -} -- | Located Field Occurrence-type LFieldOcc name = Located (FieldOcc name)+type LFieldOcc pass = Located (FieldOcc pass) -- | Field Occurrence -- -- Represents an *occurrence* of an unambiguous field. We store -- both the 'RdrName' the user originally wrote, and after the -- renamer, the selector function.-data FieldOcc name = FieldOcc { rdrNameFieldOcc :: Located RdrName+data FieldOcc pass = FieldOcc { rdrNameFieldOcc :: Located RdrName -- ^ See Note [Located RdrNames] in HsExpr- , selectorFieldOcc :: PostRn name name+ , selectorFieldOcc :: PostRn pass (IdP pass) }-deriving instance Eq (PostRn name name) => Eq (FieldOcc name)-deriving instance Ord (PostRn name name) => Ord (FieldOcc name)-deriving instance (Data name, Data (PostRn name name)) => Data (FieldOcc name)+deriving instance Eq (PostRn pass (IdP pass)) => Eq (FieldOcc pass)+deriving instance Ord (PostRn pass (IdP pass)) => Ord (FieldOcc pass)+deriving instance (DataId pass) => Data (FieldOcc pass) -instance Outputable (FieldOcc name) where+instance Outputable (FieldOcc pass) where ppr = ppr . rdrNameFieldOcc -mkFieldOcc :: Located RdrName -> FieldOcc RdrName+mkFieldOcc :: Located RdrName -> FieldOcc GhcPs mkFieldOcc rdr = FieldOcc rdr PlaceHolder @@ -1113,37 +1127,34 @@ -- See Note [HsRecField and HsRecUpdField] in HsPat and -- Note [Disambiguating record fields] in TcExpr. -- See Note [Located RdrNames] in HsExpr-data AmbiguousFieldOcc name- = Unambiguous (Located RdrName) (PostRn name name)- | Ambiguous (Located RdrName) (PostTc name name)-deriving instance ( Data name- , Data (PostRn name name)- , Data (PostTc name name))- => Data (AmbiguousFieldOcc name)+data AmbiguousFieldOcc pass+ = Unambiguous (Located RdrName) (PostRn pass (IdP pass))+ | Ambiguous (Located RdrName) (PostTc pass (IdP pass))+deriving instance DataId pass => Data (AmbiguousFieldOcc pass) -instance Outputable (AmbiguousFieldOcc name) where+instance Outputable (AmbiguousFieldOcc pass) where ppr = ppr . rdrNameAmbiguousFieldOcc -instance OutputableBndr (AmbiguousFieldOcc name) where+instance OutputableBndr (AmbiguousFieldOcc pass) where pprInfixOcc = pprInfixOcc . rdrNameAmbiguousFieldOcc pprPrefixOcc = pprPrefixOcc . rdrNameAmbiguousFieldOcc -mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc RdrName+mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs mkAmbiguousFieldOcc rdr = Unambiguous rdr PlaceHolder -rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc name -> RdrName+rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc pass -> RdrName rdrNameAmbiguousFieldOcc (Unambiguous (L _ rdr) _) = rdr rdrNameAmbiguousFieldOcc (Ambiguous (L _ rdr) _) = rdr -selectorAmbiguousFieldOcc :: AmbiguousFieldOcc Id -> Id+selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id selectorAmbiguousFieldOcc (Unambiguous _ sel) = sel selectorAmbiguousFieldOcc (Ambiguous _ sel) = sel -unambiguousFieldOcc :: AmbiguousFieldOcc Id -> FieldOcc Id+unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc unambiguousFieldOcc (Unambiguous rdr sel) = FieldOcc rdr sel unambiguousFieldOcc (Ambiguous rdr sel) = FieldOcc rdr sel -ambiguousFieldOcc :: FieldOcc name -> AmbiguousFieldOcc name+ambiguousFieldOcc :: FieldOcc pass -> AmbiguousFieldOcc pass ambiguousFieldOcc (FieldOcc rdr sel) = Unambiguous rdr sel {-@@ -1154,30 +1165,33 @@ ************************************************************************ -} -instance (OutputableBndrId name) => Outputable (HsType name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsType pass) where ppr ty = pprHsType ty instance Outputable HsTyLit where ppr = ppr_tylit -instance (OutputableBndrId name) => Outputable (LHsQTyVars name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (LHsQTyVars pass) where ppr (HsQTvs { hsq_explicit = tvs }) = interppSP tvs -instance (OutputableBndrId name) => Outputable (HsTyVarBndr name) where+instance (SourceTextX pass, OutputableBndrId pass)+ => Outputable (HsTyVarBndr pass) where ppr (UserTyVar n) = ppr n ppr (KindedTyVar n k) = parens $ hsep [ppr n, dcolon, ppr k] -instance (Outputable thing) => Outputable (HsImplicitBndrs name thing) where+instance (Outputable thing) => Outputable (HsImplicitBndrs pass thing) where ppr (HsIB { hsib_body = ty }) = ppr ty -instance (Outputable thing) => Outputable (HsWildCardBndrs name thing) where+instance (Outputable thing) => Outputable (HsWildCardBndrs pass thing) where ppr (HsWC { hswc_body = ty }) = ppr ty -instance Outputable (HsWildCardInfo name) where+instance Outputable (HsWildCardInfo pass) where ppr (AnonWildCard _) = char '_' -pprHsForAll :: (OutputableBndrId name)- => [LHsTyVarBndr name] -> LHsContext name -> SDoc+pprHsForAll :: (SourceTextX pass, OutputableBndrId pass)+ => [LHsTyVarBndr pass] -> LHsContext pass -> SDoc pprHsForAll = pprHsForAllExtra Nothing -- | Version of 'pprHsForAll' that can also print an extra-constraints@@ -1187,37 +1201,44 @@ -- function for this is needed, as the extra-constraints wildcard is removed -- from the actual context and type, and stored in a separate field, thus just -- printing the type will not print the extra-constraints wildcard.-pprHsForAllExtra :: (OutputableBndrId name)- => Maybe SrcSpan -> [LHsTyVarBndr name] -> LHsContext name+pprHsForAllExtra :: (SourceTextX pass, OutputableBndrId pass)+ => Maybe SrcSpan -> [LHsTyVarBndr pass] -> LHsContext pass -> SDoc pprHsForAllExtra extra qtvs cxt = pprHsForAllTvs qtvs <+> pprHsContextExtra show_extra (unLoc cxt) where show_extra = isJust extra -pprHsForAllTvs :: (OutputableBndrId name) => [LHsTyVarBndr name] -> SDoc-pprHsForAllTvs qtvs = sdocWithPprDebug $ \debug ->- ppWhen (debug || not (null qtvs)) $ forAllLit <+> interppSP qtvs <> dot+pprHsForAllTvs :: (SourceTextX pass, OutputableBndrId pass)+ => [LHsTyVarBndr pass] -> SDoc+pprHsForAllTvs qtvs+ | null qtvs = whenPprDebug (forAllLit <+> dot)+ | otherwise = forAllLit <+> interppSP qtvs <> dot -pprHsContext :: (OutputableBndrId name) => HsContext name -> SDoc+pprHsContext :: (SourceTextX pass, OutputableBndrId pass)+ => HsContext pass -> SDoc pprHsContext = maybe empty (<+> darrow) . pprHsContextMaybe -pprHsContextNoArrow :: (OutputableBndrId name) => HsContext name -> SDoc+pprHsContextNoArrow :: (SourceTextX pass, OutputableBndrId pass)+ => HsContext pass -> SDoc pprHsContextNoArrow = fromMaybe empty . pprHsContextMaybe -pprHsContextMaybe :: (OutputableBndrId name) => HsContext name -> Maybe SDoc+pprHsContextMaybe :: (SourceTextX pass, OutputableBndrId pass)+ => HsContext pass -> Maybe SDoc pprHsContextMaybe [] = Nothing-pprHsContextMaybe [L _ pred] = Just $ ppr_mono_ty FunPrec pred+pprHsContextMaybe [L _ pred] = Just $ ppr_mono_ty pred pprHsContextMaybe cxt = Just $ parens (interpp'SP cxt) -- For use in a HsQualTy, which always gets printed if it exists.-pprHsContextAlways :: (OutputableBndrId name) => HsContext name -> SDoc+pprHsContextAlways :: (SourceTextX pass, OutputableBndrId pass)+ => HsContext pass -> SDoc pprHsContextAlways [] = parens empty <+> darrow-pprHsContextAlways [L _ ty] = ppr_mono_ty FunPrec ty <+> darrow+pprHsContextAlways [L _ ty] = ppr_mono_ty ty <+> darrow pprHsContextAlways cxt = parens (interpp'SP cxt) <+> darrow -- True <=> print an extra-constraints wildcard, e.g. @(Show a, _) =>@-pprHsContextExtra :: (OutputableBndrId name) => Bool -> HsContext name -> SDoc+pprHsContextExtra :: (SourceTextX pass, OutputableBndrId pass)+ => Bool -> HsContext pass -> SDoc pprHsContextExtra show_extra ctxt | not show_extra = pprHsContext ctxt@@ -1228,7 +1249,8 @@ where ctxt' = map ppr ctxt ++ [char '_'] -pprConDeclFields :: (OutputableBndrId name) => [LConDeclField name] -> SDoc+pprConDeclFields :: (SourceTextX pass, OutputableBndrId pass)+ => [LConDeclField pass] -> SDoc pprConDeclFields fields = braces (sep (punctuate comma (map ppr_fld fields))) where ppr_fld (L _ (ConDeclField { cd_fld_names = ns, cd_fld_type = ty,@@ -1252,98 +1274,114 @@ -- Printing works more-or-less as for Types -pprHsType, pprParendHsType :: (OutputableBndrId name) => HsType name -> SDoc--pprHsType ty = ppr_mono_ty TopPrec ty-pprParendHsType ty = ppr_mono_ty TyConPrec ty+pprHsType :: (SourceTextX pass, OutputableBndrId pass) => HsType pass -> SDoc+pprHsType ty = ppr_mono_ty ty -ppr_mono_lty :: (OutputableBndrId name) => TyPrec -> LHsType name -> SDoc-ppr_mono_lty ctxt_prec ty = ppr_mono_ty ctxt_prec (unLoc ty)+ppr_mono_lty :: (SourceTextX pass, OutputableBndrId pass)+ => LHsType pass -> SDoc+ppr_mono_lty ty = ppr_mono_ty (unLoc ty) -ppr_mono_ty :: (OutputableBndrId name) => TyPrec -> HsType name -> SDoc-ppr_mono_ty ctxt_prec (HsForAllTy { hst_bndrs = tvs, hst_body = ty })- = maybeParen ctxt_prec FunPrec $- sep [pprHsForAllTvs tvs, ppr_mono_lty TopPrec ty]+ppr_mono_ty :: (SourceTextX pass, OutputableBndrId pass)+ => HsType pass -> SDoc+ppr_mono_ty (HsForAllTy { hst_bndrs = tvs, hst_body = ty })+ = sep [pprHsForAllTvs tvs, ppr_mono_lty ty] -ppr_mono_ty _ctxt_prec (HsQualTy { hst_ctxt = L _ ctxt, hst_body = ty })- = sep [pprHsContextAlways ctxt, ppr_mono_lty TopPrec ty]+ppr_mono_ty (HsQualTy { hst_ctxt = L _ ctxt, hst_body = ty })+ = sep [pprHsContextAlways ctxt, ppr_mono_lty ty] -ppr_mono_ty _ (HsBangTy b ty) = ppr b <> ppr_mono_lty TyConPrec ty-ppr_mono_ty _ (HsRecTy flds) = pprConDeclFields flds-ppr_mono_ty _ (HsTyVar NotPromoted (L _ name))= pprPrefixOcc name-ppr_mono_ty _ (HsTyVar Promoted (L _ name))+ppr_mono_ty (HsBangTy b ty) = ppr b <> ppr_mono_lty ty+ppr_mono_ty (HsRecTy flds) = pprConDeclFields flds+ppr_mono_ty (HsTyVar NotPromoted (L _ name))= pprPrefixOcc name+ppr_mono_ty (HsTyVar Promoted (L _ name)) = space <> quote (pprPrefixOcc name) -- We need a space before the ' above, so the parser -- does not attach it to the previous symbol-ppr_mono_ty prec (HsFunTy ty1 ty2) = ppr_fun_ty prec ty1 ty2-ppr_mono_ty _ (HsTupleTy con tys) = tupleParens std_con (pprWithCommas ppr tys)+ppr_mono_ty (HsFunTy ty1 ty2) = ppr_fun_ty ty1 ty2+ppr_mono_ty (HsTupleTy con tys) = tupleParens std_con (pprWithCommas ppr tys) where std_con = case con of HsUnboxedTuple -> UnboxedTuple _ -> BoxedTuple-ppr_mono_ty _ (HsSumTy tys) = tupleParens UnboxedTuple (pprWithBars ppr tys)-ppr_mono_ty _ (HsKindSig ty kind) = parens (ppr_mono_lty TopPrec ty <+> dcolon <+> ppr kind)-ppr_mono_ty _ (HsListTy ty) = brackets (ppr_mono_lty TopPrec ty)-ppr_mono_ty _ (HsPArrTy ty) = paBrackets (ppr_mono_lty TopPrec ty)-ppr_mono_ty prec (HsIParamTy n ty) = maybeParen prec FunPrec (ppr n <+> dcolon <+> ppr_mono_lty TopPrec ty)-ppr_mono_ty _ (HsSpliceTy s _) = pprSplice s-ppr_mono_ty _ (HsCoreTy ty) = ppr ty-ppr_mono_ty _ (HsExplicitListTy Promoted _ tys)+ppr_mono_ty (HsSumTy tys) = tupleParens UnboxedTuple (pprWithBars ppr tys)+ppr_mono_ty (HsKindSig ty kind) = parens (ppr_mono_lty ty <+> dcolon <+> ppr kind)+ppr_mono_ty (HsListTy ty) = brackets (ppr_mono_lty ty)+ppr_mono_ty (HsPArrTy ty) = paBrackets (ppr_mono_lty ty)+ppr_mono_ty (HsIParamTy n ty) = (ppr n <+> dcolon <+> ppr_mono_lty ty)+ppr_mono_ty (HsSpliceTy s _) = pprSplice s+ppr_mono_ty (HsCoreTy ty) = ppr ty+ppr_mono_ty (HsExplicitListTy Promoted _ tys) = quote $ brackets (interpp'SP tys)-ppr_mono_ty _ (HsExplicitListTy NotPromoted _ tys)+ppr_mono_ty (HsExplicitListTy NotPromoted _ tys) = brackets (interpp'SP tys)-ppr_mono_ty _ (HsExplicitTupleTy _ tys) = quote $ parens (interpp'SP tys)-ppr_mono_ty _ (HsTyLit t) = ppr_tylit t-ppr_mono_ty _ (HsWildCardTy {}) = char '_'+ppr_mono_ty (HsExplicitTupleTy _ tys) = quote $ parens (interpp'SP tys)+ppr_mono_ty (HsTyLit t) = ppr_tylit t+ppr_mono_ty (HsWildCardTy {}) = char '_' -ppr_mono_ty ctxt_prec (HsEqTy ty1 ty2)- = maybeParen ctxt_prec TyOpPrec $- ppr_mono_lty TyOpPrec ty1 <+> char '~' <+> ppr_mono_lty TyOpPrec ty2+ppr_mono_ty (HsEqTy ty1 ty2)+ = ppr_mono_lty ty1 <+> char '~' <+> ppr_mono_lty ty2 -ppr_mono_ty _ctxt_prec (HsAppsTy tys)- = hsep (map (ppr_app_ty TopPrec . unLoc) tys)+ppr_mono_ty (HsAppsTy tys)+ = hsep (map (ppr_app_ty . unLoc) tys) -ppr_mono_ty _ctxt_prec (HsAppTy fun_ty arg_ty)- = hsep [ppr_mono_lty FunPrec fun_ty, ppr_mono_lty TyConPrec arg_ty]+ppr_mono_ty (HsAppTy fun_ty arg_ty)+ = hsep [ppr_mono_lty fun_ty, ppr_mono_lty arg_ty] -ppr_mono_ty ctxt_prec (HsOpTy ty1 (L _ op) ty2)- = maybeParen ctxt_prec TyOpPrec $- sep [ ppr_mono_lty TyOpPrec ty1- , sep [pprInfixOcc op, ppr_mono_lty TyOpPrec ty2 ] ]+ppr_mono_ty (HsOpTy ty1 (L _ op) ty2)+ = sep [ ppr_mono_lty ty1+ , sep [pprInfixOcc op, ppr_mono_lty ty2 ] ] -ppr_mono_ty _ (HsParTy ty)- = parens (ppr_mono_lty TopPrec ty)+ppr_mono_ty (HsParTy ty)+ = parens (ppr_mono_lty ty) -- Put the parens in where the user did -- But we still use the precedence stuff to add parens because -- toHsType doesn't put in any HsParTys, so we may still need them -ppr_mono_ty ctxt_prec (HsDocTy ty doc)- = maybeParen ctxt_prec TyOpPrec $- ppr_mono_lty TyOpPrec ty <+> ppr (unLoc doc)+ppr_mono_ty (HsDocTy ty doc)+ -- AZ: Should we add parens? Should we introduce "-- ^"?+ = ppr_mono_lty ty <+> ppr (unLoc doc) -- we pretty print Haddock comments on types as if they were -- postfix operators ---------------------------ppr_fun_ty :: (OutputableBndrId name)- => TyPrec -> LHsType name -> LHsType name -> SDoc-ppr_fun_ty ctxt_prec ty1 ty2- = let p1 = ppr_mono_lty FunPrec ty1- p2 = ppr_mono_lty TopPrec ty2+ppr_fun_ty :: (SourceTextX pass, OutputableBndrId pass)+ => LHsType pass -> LHsType pass -> SDoc+ppr_fun_ty ty1 ty2+ = let p1 = ppr_mono_lty ty1+ p2 = ppr_mono_lty ty2 in- maybeParen ctxt_prec FunPrec $ sep [p1, text "->" <+> p2] ---------------------------ppr_app_ty :: (OutputableBndrId name) => TyPrec -> HsAppType name -> SDoc-ppr_app_ty _ (HsAppInfix (L _ n)) = pprInfixOcc n-ppr_app_ty _ (HsAppPrefix (L _ (HsTyVar NotPromoted (L _ n))))+ppr_app_ty :: (SourceTextX pass, OutputableBndrId pass)+ => HsAppType pass -> SDoc+ppr_app_ty (HsAppInfix (L _ n)) = pprInfixOcc n+ppr_app_ty (HsAppPrefix (L _ (HsTyVar NotPromoted (L _ n)))) = pprPrefixOcc n-ppr_app_ty _ (HsAppPrefix (L _ (HsTyVar Promoted (L _ n))))+ppr_app_ty (HsAppPrefix (L _ (HsTyVar Promoted (L _ n)))) = space <> quote (pprPrefixOcc n) -- We need a space before the ' above, so -- the parser does not attach it to the -- previous symbol-ppr_app_ty ctxt (HsAppPrefix ty) = ppr_mono_lty ctxt ty+ppr_app_ty (HsAppPrefix ty) = ppr_mono_lty ty -------------------------- ppr_tylit :: HsTyLit -> SDoc ppr_tylit (HsNumTy _ i) = integer i ppr_tylit (HsStrTy _ s) = text (show s)+++-- | Return 'True' for compound types that will need parentheses when used in+-- an argument position.+isCompoundHsType :: LHsType pass -> Bool+isCompoundHsType (L _ HsAppTy{} ) = True+isCompoundHsType (L _ HsAppsTy{}) = True+isCompoundHsType (L _ HsEqTy{} ) = True+isCompoundHsType (L _ HsFunTy{} ) = True+isCompoundHsType (L _ HsOpTy{} ) = True+isCompoundHsType _ = False++-- | @'parenthesizeCompoundHsType' ty@ checks if @'isCompoundHsType' ty@ is+-- true, and if so, surrounds @ty@ with an 'HsParTy'. Otherwise, it simply+-- returns @ty@.+parenthesizeCompoundHsType :: LHsType pass -> LHsType pass+parenthesizeCompoundHsType ty@(L loc _)+ | isCompoundHsType ty = L loc (HsParTy ty)+ | otherwise = ty
hsSyn/HsUtils.hs view
@@ -6,11 +6,11 @@ analyse HsSyn. All these functions deal with generic HsSyn; functions which deal with the instantiated versions are located elsewhere: - Parameterised by Module- ---------------- -------------- RdrName parser/RdrHsSyn- Name rename/RnHsSyn- Id typecheck/TcHsSyn+ Parameterised by Module+ ---------------- -------------+ GhcPs/RdrName parser/RdrHsSyn+ GhcRn/Name rename/RnHsSyn+ GhcTc/Id typecheck/TcHsSyn -} {-# LANGUAGE CPP #-}@@ -20,7 +20,7 @@ module HsUtils( -- Terms- mkHsPar, mkHsApp, mkHsAppType, mkHsAppTypeOut, mkHsCaseAlt,+ mkHsPar, mkHsApp, mkHsAppType, mkHsAppTypes, mkHsAppTypeOut, mkHsCaseAlt, mkSimpleMatch, unguardedGRHSs, unguardedRHS, mkMatchGroup, mkMatch, mkPrefixFunRhs, mkHsLam, mkHsIf, mkHsWrap, mkLHsWrap, mkHsWrapCo, mkHsWrapCoR, mkLHsWrapCo,@@ -72,7 +72,7 @@ noRebindableInfo, -- Collecting binders- isUnliftedHsBind, isBangedBind,+ isUnliftedHsBind, isBangedHsBind, collectLocalBinders, collectHsValBinders, collectHsBindListBinders, collectHsIdBinders,@@ -92,6 +92,8 @@ #include "HsVersions.h" +import GhcPrelude+ import HsDecls import HsBinds import HsExpr@@ -99,6 +101,7 @@ import HsTypes import HsLit import PlaceHolder+import HsExtension import TcEvidence import RdrName@@ -120,6 +123,7 @@ import Bag import Outputable import Constants+import TyCon import Data.Either import Data.Function@@ -140,12 +144,13 @@ mkHsPar :: LHsExpr id -> LHsExpr id mkHsPar e = L (getLoc e) (HsPar e) -mkSimpleMatch :: HsMatchContext (NameOrRdrName id)+mkSimpleMatch :: HsMatchContext (NameOrRdrName (IdP id)) -> [LPat id] -> Located (body id) -> LMatch id (Located (body id)) mkSimpleMatch ctxt pats rhs = L loc $- Match ctxt pats Nothing (unguardedGRHSs rhs)+ Match { m_ctxt = ctxt, m_pats = pats+ , m_grhss = unguardedGRHSs rhs } where loc = case pats of [] -> getLoc rhs@@ -176,16 +181,20 @@ mkHsAppType :: LHsExpr name -> LHsWcType name -> LHsExpr name mkHsAppType e t = addCLoc e (hswc_body t) (HsAppType e t) -mkHsAppTypeOut :: LHsExpr Id -> LHsWcType Name -> LHsExpr Id+mkHsAppTypes :: LHsExpr name -> [LHsWcType name] -> LHsExpr name+mkHsAppTypes = foldl mkHsAppType++mkHsAppTypeOut :: LHsExpr GhcTc -> LHsWcType GhcRn -> LHsExpr GhcTc mkHsAppTypeOut e t = addCLoc e (hswc_body t) (HsAppTypeOut e t) -mkHsLam :: [LPat RdrName] -> LHsExpr RdrName -> LHsExpr RdrName+mkHsLam :: [LPat GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs mkHsLam pats body = mkHsPar (L (getLoc body) (HsLam matches)) where matches = mkMatchGroup Generated- [mkSimpleMatch LambdaExpr pats body]+ [mkSimpleMatch LambdaExpr pats' body]+ pats' = map parenthesizeCompoundPat pats -mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr Id -> LHsExpr Id+mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr GhcTc -> LHsExpr GhcTc mkHsLams tyvars dicts expr = mkLHsWrap (mkWpTyLams tyvars <.> mkWpLams dicts) expr @@ -195,10 +204,10 @@ mkHsCaseAlt pat expr = mkSimpleMatch CaseAlt [pat] expr -nlHsTyApp :: name -> [Type] -> LHsExpr name-nlHsTyApp fun_id tys = noLoc (HsWrap (mkWpTyApps tys) (HsVar (noLoc fun_id)))+nlHsTyApp :: IdP name -> [Type] -> LHsExpr name+nlHsTyApp fun_id tys = noLoc (mkHsWrap (mkWpTyApps tys) (HsVar (noLoc fun_id))) -nlHsTyApps :: name -> [Type] -> [LHsExpr name] -> LHsExpr name+nlHsTyApps :: IdP name -> [Type] -> [LHsExpr name] -> LHsExpr name nlHsTyApps fun_id tys xs = foldl nlHsApp (nlHsTyApp fun_id tys) xs --------- Adding parens ---------@@ -219,33 +228,36 @@ -- These are the bits of syntax that contain rebindable names -- See RnEnv.lookupSyntaxName -mkHsIntegral :: SourceText -> Integer -> PostTc RdrName Type- -> HsOverLit RdrName-mkHsFractional :: FractionalLit -> PostTc RdrName Type -> HsOverLit RdrName-mkHsIsString :: SourceText -> FastString -> PostTc RdrName Type- -> HsOverLit RdrName-mkHsDo :: HsStmtContext Name -> [ExprLStmt RdrName] -> HsExpr RdrName-mkHsComp :: HsStmtContext Name -> [ExprLStmt RdrName] -> LHsExpr RdrName- -> HsExpr RdrName+mkHsIntegral :: IntegralLit -> PostTc GhcPs Type+ -> HsOverLit GhcPs+mkHsFractional :: FractionalLit -> PostTc GhcPs Type -> HsOverLit GhcPs+mkHsIsString :: SourceText -> FastString -> PostTc GhcPs Type+ -> HsOverLit GhcPs+mkHsDo :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs+mkHsComp :: HsStmtContext Name -> [ExprLStmt GhcPs] -> LHsExpr GhcPs+ -> HsExpr GhcPs -mkNPat :: Located (HsOverLit RdrName) -> Maybe (SyntaxExpr RdrName) -> Pat RdrName-mkNPlusKPat :: Located RdrName -> Located (HsOverLit RdrName) -> Pat RdrName+mkNPat :: Located (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs)+ -> Pat GhcPs+mkNPlusKPat :: Located RdrName -> Located (HsOverLit GhcPs) -> Pat GhcPs -mkLastStmt :: Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))-mkBodyStmt :: Located (bodyR RdrName)- -> StmtLR idL RdrName (Located (bodyR RdrName))-mkBindStmt :: (PostTc idR Type ~ PlaceHolder)+mkLastStmt :: SourceTextX idR+ => Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))+mkBodyStmt :: Located (bodyR GhcPs)+ -> StmtLR idL GhcPs (Located (bodyR GhcPs))+mkBindStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => LPat idL -> Located (bodyR idR) -> StmtLR idL idR (Located (bodyR idR))-mkTcBindStmt :: LPat Id -> Located (bodyR Id) -> StmtLR Id Id (Located (bodyR Id))+mkTcBindStmt :: LPat GhcTc -> Located (bodyR GhcTc)+ -> StmtLR GhcTc GhcTc (Located (bodyR GhcTc)) -emptyRecStmt :: StmtLR idL RdrName bodyR-emptyRecStmtName :: StmtLR Name Name bodyR-emptyRecStmtId :: StmtLR Id Id bodyR-mkRecStmt :: [LStmtLR idL RdrName bodyR] -> StmtLR idL RdrName bodyR+emptyRecStmt :: StmtLR idL GhcPs bodyR+emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR+emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR+mkRecStmt :: [LStmtLR idL GhcPs bodyR] -> StmtLR idL GhcPs bodyR -mkHsIntegral src i = OverLit (HsIntegral src i) noRebindableInfo noExpr+mkHsIntegral i = OverLit (HsIntegral i) noRebindableInfo noExpr mkHsFractional f = OverLit (HsFractional f) noRebindableInfo noExpr mkHsIsString src s = OverLit (HsIsString src s) noRebindableInfo noExpr @@ -257,26 +269,27 @@ where last_stmt = L (getLoc expr) $ mkLastStmt expr -mkHsIf :: LHsExpr id -> LHsExpr id -> LHsExpr id -> HsExpr id+mkHsIf :: SourceTextX p => LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p mkHsIf c a b = HsIf (Just noSyntaxExpr) c a b mkNPat lit neg = NPat lit neg noSyntaxExpr placeHolderType mkNPlusKPat id lit = NPlusKPat id lit (unLoc lit) noSyntaxExpr noSyntaxExpr placeHolderType -mkTransformStmt :: (PostTc idR Type ~ PlaceHolder)+mkTransformStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)-mkTransformByStmt :: (PostTc idR Type ~ PlaceHolder)+mkTransformByStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)-mkGroupUsingStmt :: (PostTc idR Type ~ PlaceHolder)+mkGroupUsingStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL)-mkGroupByUsingStmt :: (PostTc idR Type ~ PlaceHolder)+mkGroupByUsingStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder) => [ExprLStmt idL] -> LHsExpr idR -> LHsExpr idR -> StmtLR idL idR (LHsExpr idL) -emptyTransStmt :: (PostTc idR Type ~ PlaceHolder) => StmtLR idL idR (LHsExpr idR)+emptyTransStmt :: (SourceTextX idR, PostTc idR Type ~ PlaceHolder)+ => StmtLR idL idR (LHsExpr idR) emptyTransStmt = TransStmt { trS_form = panic "emptyTransStmt: form" , trS_stmts = [], trS_bndrs = [] , trS_by = Nothing, trS_using = noLoc noExpr@@ -294,7 +307,7 @@ mkTcBindStmt pat body = BindStmt pat body noSyntaxExpr noSyntaxExpr unitTy -- don't use placeHolderTypeTc above, because that panics during zonking -emptyRecStmt' :: forall idL idR body.+emptyRecStmt' :: forall idL idR body. SourceTextX idR => PostTc idR Type -> StmtLR idL idR body emptyRecStmt' tyVal = RecStmt@@ -314,27 +327,27 @@ ------------------------------- --- A useful function for building @OpApps@. The operator is always a -- variable, and we don't know the fixity yet.-mkHsOpApp :: LHsExpr id -> id -> LHsExpr id -> HsExpr id+mkHsOpApp :: LHsExpr id -> IdP id -> LHsExpr id -> HsExpr id mkHsOpApp e1 op e2 = OpApp e1 (noLoc (HsVar (noLoc op))) (error "mkOpApp:fixity") e2 unqualSplice :: RdrName unqualSplice = mkRdrUnqual (mkVarOccFS (fsLit "splice")) -mkUntypedSplice :: SpliceDecoration -> LHsExpr RdrName -> HsSplice RdrName+mkUntypedSplice :: SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs mkUntypedSplice hasParen e = HsUntypedSplice hasParen unqualSplice e -mkHsSpliceE :: SpliceDecoration -> LHsExpr RdrName -> HsExpr RdrName+mkHsSpliceE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs mkHsSpliceE hasParen e = HsSpliceE (mkUntypedSplice hasParen e) -mkHsSpliceTE :: SpliceDecoration -> LHsExpr RdrName -> HsExpr RdrName+mkHsSpliceTE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs mkHsSpliceTE hasParen e = HsSpliceE (HsTypedSplice hasParen unqualSplice e) -mkHsSpliceTy :: SpliceDecoration -> LHsExpr RdrName -> HsType RdrName+mkHsSpliceTy :: SpliceDecoration -> LHsExpr GhcPs -> HsType GhcPs mkHsSpliceTy hasParen e = HsSpliceTy (HsUntypedSplice hasParen unqualSplice e) placeHolderKind -mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice RdrName+mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice GhcPs mkHsQuasiQuote quoter span quote = HsQuasiQuote unqualSplice quoter span quote unqualQuasiQuote :: RdrName@@ -342,19 +355,19 @@ -- A name (uniquified later) to -- identify the quasi-quote -mkHsString :: String -> HsLit-mkHsString s = HsString NoSourceText (mkFastString s)+mkHsString :: SourceTextX p => String -> HsLit p+mkHsString s = HsString noSourceText (mkFastString s) -mkHsStringPrimLit :: FastString -> HsLit+mkHsStringPrimLit :: SourceTextX p => FastString -> HsLit p mkHsStringPrimLit fs- = HsStringPrim NoSourceText (fastStringToByteString fs)+ = HsStringPrim noSourceText (fastStringToByteString fs) --------------userHsLTyVarBndrs :: SrcSpan -> [Located name] -> [LHsTyVarBndr name]+userHsLTyVarBndrs :: SrcSpan -> [Located (IdP name)] -> [LHsTyVarBndr name] -- Caller sets location userHsLTyVarBndrs loc bndrs = [ L loc (UserTyVar v) | v <- bndrs ] -userHsTyVarBndrs :: SrcSpan -> [name] -> [LHsTyVarBndr name]+userHsTyVarBndrs :: SrcSpan -> [IdP name] -> [LHsTyVarBndr name] -- Caller sets location userHsTyVarBndrs loc bndrs = [ L loc (UserTyVar (L loc v)) | v <- bndrs ] @@ -367,20 +380,23 @@ ************************************************************************ -} -nlHsVar :: id -> LHsExpr id+nlHsVar :: IdP id -> LHsExpr id nlHsVar n = noLoc (HsVar (noLoc n)) -- NB: Only for LHsExpr **Id**-nlHsDataCon :: DataCon -> LHsExpr Id+nlHsDataCon :: DataCon -> LHsExpr GhcTc nlHsDataCon con = noLoc (HsConLikeOut (RealDataCon con)) -nlHsLit :: HsLit -> LHsExpr id+nlHsLit :: HsLit p -> LHsExpr p nlHsLit n = noLoc (HsLit n) -nlVarPat :: id -> LPat id+nlHsIntLit :: HasDefaultX p => Integer -> LHsExpr p+nlHsIntLit n = noLoc (HsLit (HsInt def (mkIntegralLit n)))++nlVarPat :: IdP id -> LPat id nlVarPat n = noLoc (VarPat (noLoc n)) -nlLitPat :: HsLit -> LPat id+nlLitPat :: HsLit p -> LPat p nlLitPat l = noLoc (LitPat l) nlHsApp :: LHsExpr id -> LHsExpr id -> LHsExpr id@@ -398,62 +414,61 @@ = mkLHsWrap res_wrap (foldl nlHsApp (noLoc fun) (zipWithEqual "nlHsSyntaxApps" mkLHsWrap arg_wraps args)) -nlHsIntLit :: Integer -> LHsExpr id-nlHsIntLit n = noLoc (HsLit (HsInt NoSourceText n))--nlHsApps :: id -> [LHsExpr id] -> LHsExpr id+nlHsApps :: IdP id -> [LHsExpr id] -> LHsExpr id nlHsApps f xs = foldl nlHsApp (nlHsVar f) xs -nlHsVarApps :: id -> [id] -> LHsExpr id+nlHsVarApps :: IdP id -> [IdP id] -> LHsExpr id nlHsVarApps f xs = noLoc (foldl mk (HsVar (noLoc f)) (map (HsVar . noLoc) xs)) where mk f a = HsApp (noLoc f) (noLoc a) -nlConVarPat :: RdrName -> [RdrName] -> LPat RdrName+nlConVarPat :: RdrName -> [RdrName] -> LPat GhcPs nlConVarPat con vars = nlConPat con (map nlVarPat vars) -nlConVarPatName :: Name -> [Name] -> LPat Name+nlConVarPatName :: Name -> [Name] -> LPat GhcRn nlConVarPatName con vars = nlConPatName con (map nlVarPat vars) -nlInfixConPat :: id -> LPat id -> LPat id -> LPat id+nlInfixConPat :: IdP id -> LPat id -> LPat id -> LPat id nlInfixConPat con l r = noLoc (ConPatIn (noLoc con) (InfixCon l r)) -nlConPat :: RdrName -> [LPat RdrName] -> LPat RdrName-nlConPat con pats = noLoc (ConPatIn (noLoc con) (PrefixCon pats))+nlConPat :: RdrName -> [LPat GhcPs] -> LPat GhcPs+nlConPat con pats =+ noLoc (ConPatIn (noLoc con) (PrefixCon (map parenthesizeCompoundPat pats))) -nlConPatName :: Name -> [LPat Name] -> LPat Name-nlConPatName con pats = noLoc (ConPatIn (noLoc con) (PrefixCon pats))+nlConPatName :: Name -> [LPat GhcRn] -> LPat GhcRn+nlConPatName con pats =+ noLoc (ConPatIn (noLoc con) (PrefixCon (map parenthesizeCompoundPat pats))) -nlNullaryConPat :: id -> LPat id+nlNullaryConPat :: IdP id -> LPat id nlNullaryConPat con = noLoc (ConPatIn (noLoc con) (PrefixCon [])) -nlWildConPat :: DataCon -> LPat RdrName+nlWildConPat :: DataCon -> LPat GhcPs nlWildConPat con = noLoc (ConPatIn (noLoc (getRdrName con)) (PrefixCon (nOfThem (dataConSourceArity con) nlWildPat))) -nlWildPat :: LPat RdrName+nlWildPat :: LPat GhcPs nlWildPat = noLoc (WildPat placeHolderType ) -- Pre-typechecking -nlWildPatName :: LPat Name+nlWildPatName :: LPat GhcRn nlWildPatName = noLoc (WildPat placeHolderType ) -- Pre-typechecking -nlWildPatId :: LPat Id+nlWildPatId :: LPat GhcTc nlWildPatId = noLoc (WildPat placeHolderTypeTc ) -- Post-typechecking -nlHsDo :: HsStmtContext Name -> [LStmt RdrName (LHsExpr RdrName)]- -> LHsExpr RdrName+nlHsDo :: HsStmtContext Name -> [LStmt GhcPs (LHsExpr GhcPs)]+ -> LHsExpr GhcPs nlHsDo ctxt stmts = noLoc (mkHsDo ctxt stmts) -nlHsOpApp :: LHsExpr id -> id -> LHsExpr id -> LHsExpr id+nlHsOpApp :: LHsExpr id -> IdP id -> LHsExpr id -> LHsExpr id nlHsOpApp e1 op e2 = noLoc (mkHsOpApp e1 op e2) -nlHsLam :: LMatch RdrName (LHsExpr RdrName) -> LHsExpr RdrName+nlHsLam :: LMatch GhcPs (LHsExpr GhcPs) -> LHsExpr GhcPs nlHsPar :: LHsExpr id -> LHsExpr id nlHsIf :: LHsExpr id -> LHsExpr id -> LHsExpr id -> LHsExpr id-nlHsCase :: LHsExpr RdrName -> [LMatch RdrName (LHsExpr RdrName)]- -> LHsExpr RdrName-nlList :: [LHsExpr RdrName] -> LHsExpr RdrName+nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)]+ -> LHsExpr GhcPs+nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs nlHsLam match = noLoc (HsLam (mkMatchGroup Generated [match])) nlHsPar e = noLoc (HsPar e)@@ -467,16 +482,16 @@ nlList exprs = noLoc (ExplicitList placeHolderType Nothing exprs) nlHsAppTy :: LHsType name -> LHsType name -> LHsType name-nlHsTyVar :: name -> LHsType name+nlHsTyVar :: IdP name -> LHsType name nlHsFunTy :: LHsType name -> LHsType name -> LHsType name nlHsParTy :: LHsType name -> LHsType name -nlHsAppTy f t = noLoc (HsAppTy f t)-nlHsTyVar x = noLoc (HsTyVar NotPromoted (noLoc x))-nlHsFunTy a b = noLoc (HsFunTy a b)-nlHsParTy t = noLoc (HsParTy t)+nlHsAppTy f t = noLoc (HsAppTy f (parenthesizeCompoundHsType t))+nlHsTyVar x = noLoc (HsTyVar NotPromoted (noLoc x))+nlHsFunTy a b = noLoc (HsFunTy a b)+nlHsParTy t = noLoc (HsParTy t) -nlHsTyConApp :: name -> [LHsType name] -> LHsType name+nlHsTyConApp :: IdP name -> [LHsType name] -> LHsType name nlHsTyConApp tycon tys = foldl nlHsAppTy (nlHsTyVar tycon) tys {-@@ -489,13 +504,13 @@ mkLHsTupleExpr [e] = e mkLHsTupleExpr es = noLoc $ ExplicitTuple (map (noLoc . Present) es) Boxed -mkLHsVarTuple :: [a] -> LHsExpr a+mkLHsVarTuple :: [IdP a] -> LHsExpr a mkLHsVarTuple ids = mkLHsTupleExpr (map nlHsVar ids) nlTuplePat :: [LPat id] -> Boxity -> LPat id nlTuplePat pats box = noLoc (TuplePat pats box []) -missingTupArg :: HsTupArg RdrName+missingTupArg :: HsTupArg GhcPs missingTupArg = Missing placeHolderType mkLHsPatTup :: [LPat id] -> LPat id@@ -504,14 +519,14 @@ mkLHsPatTup lpats = L (getLoc (head lpats)) $ TuplePat lpats Boxed [] -- The Big equivalents for the source tuple expressions-mkBigLHsVarTup :: [id] -> LHsExpr id+mkBigLHsVarTup :: [IdP id] -> LHsExpr id mkBigLHsVarTup ids = mkBigLHsTup (map nlHsVar ids) mkBigLHsTup :: [LHsExpr id] -> LHsExpr id mkBigLHsTup = mkChunkified mkLHsTupleExpr -- The Big equivalents for the source tuple patterns-mkBigLHsVarPatTup :: [id] -> LPat id+mkBigLHsVarPatTup :: [IdP id] -> LPat id mkBigLHsVarPatTup bs = mkBigLHsPatTup (map nlVarPat bs) mkBigLHsPatTup :: [LPat id] -> LPat id@@ -565,14 +580,14 @@ * * ********************************************************************* -} -mkLHsSigType :: LHsType RdrName -> LHsSigType RdrName+mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs mkLHsSigType ty = mkHsImplicitBndrs ty -mkLHsSigWcType :: LHsType RdrName -> LHsSigWcType RdrName+mkLHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs mkLHsSigWcType ty = mkHsWildCardBndrs (mkHsImplicitBndrs ty) -mkHsSigEnv :: forall a. (LSig Name -> Maybe ([Located Name], a))- -> [LSig Name]+mkHsSigEnv :: forall a. (LSig GhcRn -> Maybe ([Located Name], a))+ -> [LSig GhcRn] -> NameEnv a mkHsSigEnv get_info sigs = mkNameEnv (mk_pairs ordinary_sigs)@@ -593,11 +608,11 @@ is_gen_dm_sig (L _ (ClassOpSig True _ _)) = True is_gen_dm_sig _ = False - mk_pairs :: [LSig Name] -> [(Name, a)]+ mk_pairs :: [LSig GhcRn] -> [(Name, a)] mk_pairs sigs = [ (n,a) | Just (ns,a) <- map get_info sigs , L _ n <- ns ] -mkClassOpSigs :: [LSig RdrName] -> [LSig RdrName]+mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs] -- Convert TypeSig to ClassOpSig -- The former is what is parsed, but the latter is -- what we need in class/instance declarations@@ -607,7 +622,7 @@ fiddle (L loc (TypeSig nms ty)) = L loc (ClassOpSig False nms (dropWildCards ty)) fiddle sig = sig -typeToLHsType :: Type -> LHsType RdrName+typeToLHsType :: Type -> LHsType GhcPs -- ^ Converting a Type to an HsType RdrName -- This is needed to implement GeneralizedNewtypeDeriving. --@@ -616,7 +631,7 @@ typeToLHsType ty = go ty where- go :: Type -> LHsType RdrName+ go :: Type -> LHsType GhcPs go ty@(FunTy arg _) | isPredTy arg , (theta, tau) <- tcSplitPhiTy ty@@ -629,22 +644,77 @@ , hst_body = go tau }) go (TyVarTy tv) = nlHsTyVar (getRdrName tv) go (AppTy t1 t2) = nlHsAppTy (go t1) (go t2)- go (LitTy (NumTyLit n)) = noLoc $ HsTyLit (HsNumTy NoSourceText n)- go (LitTy (StrTyLit s)) = noLoc $ HsTyLit (HsStrTy NoSourceText s)- go (TyConApp tc args) = nlHsTyConApp (getRdrName tc) (map go args')+ go (LitTy (NumTyLit n)) = noLoc $ HsTyLit (HsNumTy noSourceText n)+ go (LitTy (StrTyLit s)) = noLoc $ HsTyLit (HsStrTy noSourceText s)+ go ty@(TyConApp tc args)+ | any isInvisibleTyConBinder (tyConBinders tc)+ -- We must produce an explicit kind signature here to make certain+ -- programs kind-check. See Note [Kind signatures in typeToLHsType].+ = noLoc $ HsKindSig lhs_ty (go (typeKind ty))+ | otherwise = lhs_ty where- args' = filterOutInvisibleTypes tc args+ lhs_ty = nlHsTyConApp (getRdrName tc) (map go args')+ args' = filterOutInvisibleTypes tc args go (CastTy ty _) = go ty go (CoercionTy co) = pprPanic "toLHsSigWcType" (ppr co) -- Source-language types have _invisible_ kind arguments, -- so we must remove them here (Trac #8563) - go_tv :: TyVar -> LHsTyVarBndr RdrName+ go_tv :: TyVar -> LHsTyVarBndr GhcPs go_tv tv = noLoc $ KindedTyVar (noLoc (getRdrName tv)) (go (tyVarKind tv)) +{-+Note [Kind signatures in typeToLHsType]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+There are types that typeToLHsType can produce which require explicit kind+signatures in order to kind-check. Here is an example from Trac #14579: + newtype Wat (x :: Proxy (a :: Type)) = MkWat (Maybe a) deriving Eq+ newtype Glurp a = MkGlurp (Wat ('Proxy :: Proxy a)) deriving Eq++The derived Eq instance for Glurp (without any kind signatures) would be:++ instance Eq a => Eq (Glurp a) where+ (==) = coerce @(Wat 'Proxy -> Wat 'Proxy -> Bool)+ @(Glurp a -> Glurp a -> Bool)+ (==)++(Where the visible type applications use types produced by typeToLHsType.)++The type 'Proxy has an underspecified kind, so we must ensure that+typeToLHsType ascribes it with its kind: ('Proxy :: Proxy a).++We must be careful not to produce too many kind signatures, or else+typeToLHsType can produce noisy types like+('Proxy :: Proxy (a :: (Type :: Type))). In pursuit of this goal, we adopt the+following criterion for choosing when to annotate types with kinds:++* If there is a tycon application with any invisible arguments, annotate+ the tycon application with its kind.++Why is this the right criterion? The problem we encountered earlier was the+result of an invisible argument (the `a` in ('Proxy :: Proxy a)) being+underspecified, so producing a kind signature for 'Proxy will catch this.+If there are no invisible arguments, then there is nothing to do, so we can+avoid polluting the result type with redundant noise.++What about a more complicated tycon, such as this?++ T :: forall {j} (a :: j). a -> Type++Unlike in the previous 'Proxy example, annotating an application of `T` to an+argument (e.g., annotating T ty to obtain (T ty :: Type)) will not fix+its invisible argument `j`. But because we apply this strategy recursively,+`j` will be fixed because the kind of `ty` will be fixed! That is to say,+something to the effect of (T (ty :: j) :: Type) will be produced.++This strategy certainly isn't foolproof, as tycons that contain type families+in their kind might break down. But we'd likely need visible kind application+to make those work.+-}+ {- ********************************************************************* * * --------- HsWrappers: type args, dict args, casts ---------@@ -654,9 +724,12 @@ mkLHsWrap :: HsWrapper -> LHsExpr id -> LHsExpr id mkLHsWrap co_fn (L loc e) = L loc (mkHsWrap co_fn e) +-- Avoid (HsWrap co (HsWrap co' _)).+-- See Note [Detecting forced eta expansion] in DsExpr mkHsWrap :: HsWrapper -> HsExpr id -> HsExpr id mkHsWrap co_fn e | isIdHsWrapper co_fn = e- | otherwise = HsWrap co_fn e+mkHsWrap co_fn (HsWrap co_fn' e) = mkHsWrap (co_fn <.> co_fn') e+mkHsWrap co_fn e = HsWrap co_fn e mkHsWrapCo :: TcCoercionN -- A Nominal coercion a ~N b -> HsExpr id -> HsExpr id@@ -684,7 +757,7 @@ mkHsWrapPatCo co pat ty | isTcReflCo co = pat | otherwise = CoPat (mkWpCastN co) pat ty -mkHsDictLet :: TcEvBinds -> LHsExpr Id -> LHsExpr Id+mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc mkHsDictLet ev_binds expr = mkLHsWrap (mkWpLet ev_binds) expr {-@@ -696,8 +769,8 @@ ************************************************************************ -} -mkFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)]- -> HsBind RdrName+mkFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)]+ -> HsBind GhcPs -- Not infix, with place holders for coercion and free vars mkFunBind fn ms = FunBind { fun_id = fn , fun_matches = mkMatchGroup Generated ms@@ -705,8 +778,8 @@ , bind_fvs = placeHolderNames , fun_tick = [] } -mkTopFunBind :: Origin -> Located Name -> [LMatch Name (LHsExpr Name)]- -> HsBind Name+mkTopFunBind :: Origin -> Located Name -> [LMatch GhcRn (LHsExpr GhcRn)]+ -> HsBind GhcRn -- In Name-land, with empty bind_fvs mkTopFunBind origin fn ms = FunBind { fun_id = fn , fun_matches = mkMatchGroup origin ms@@ -715,15 +788,15 @@ -- binding , fun_tick = [] } -mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr RdrName -> LHsBind RdrName+mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr GhcPs -> LHsBind GhcPs mkHsVarBind loc var rhs = mk_easy_FunBind loc var [] rhs -mkVarBind :: id -> LHsExpr id -> LHsBind id+mkVarBind :: IdP p -> LHsExpr p -> LHsBind p mkVarBind var rhs = L (getLoc rhs) $ VarBind { var_id = var, var_rhs = rhs, var_inline = False } mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName)- -> LPat RdrName -> HsPatSynDir RdrName -> HsBind RdrName+ -> LPat GhcPs -> HsPatSynDir GhcPs -> HsBind GhcPs mkPatSynBind name details lpat dir = PatSynBind psb where psb = PSB{ psb_id = name@@ -741,8 +814,8 @@ -------------mk_easy_FunBind :: SrcSpan -> RdrName -> [LPat RdrName]- -> LHsExpr RdrName -> LHsBind RdrName+mk_easy_FunBind :: SrcSpan -> RdrName -> [LPat GhcPs]+ -> LHsExpr GhcPs -> LHsBind GhcPs mk_easy_FunBind loc fun pats expr = L loc $ mkFunBind (L loc fun) [mkMatch (mkPrefixFunRhs (L loc fun)) pats expr@@ -750,14 +823,17 @@ -- | Make a prefix, non-strict function 'HsMatchContext' mkPrefixFunRhs :: Located id -> HsMatchContext id-mkPrefixFunRhs n = FunRhs n Prefix NoSrcStrict+mkPrefixFunRhs n = FunRhs { mc_fun = n+ , mc_fixity = Prefix+ , mc_strictness = NoSrcStrict } -------------mkMatch :: HsMatchContext (NameOrRdrName id) -> [LPat id] -> LHsExpr id- -> Located (HsLocalBinds id) -> LMatch id (LHsExpr id)+mkMatch :: HsMatchContext (NameOrRdrName (IdP p)) -> [LPat p] -> LHsExpr p+ -> Located (HsLocalBinds p) -> LMatch p (LHsExpr p) mkMatch ctxt pats expr lbinds- = noLoc (Match ctxt (map paren pats) Nothing- (GRHSs (unguardedRHS noSrcSpan expr) lbinds))+ = noLoc (Match { m_ctxt = ctxt+ , m_pats = map paren pats+ , m_grhss = GRHSs (unguardedRHS noSrcSpan expr) lbinds }) where paren lp@(L l p) | hsPatNeedsParens p = L l (ParPat lp) | otherwise = lp@@ -786,49 +862,31 @@ and wild-card mechanism makes it hard to know what is bound. So these functions should not be applied to (HsSyn RdrName) -Note [Unlifted id check in isHsUnliftedBind]+Note [Unlifted id check in isUnliftedHsBind] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Suppose there is a binding with the type (Num a => (# a, a #)). Is this a-strict binding that should be disallowed at the top level? At first glance,-no, because it's a function. But consider how this is desugared via-AbsBinds:-- -- x :: Num a => (# a, a #)- x = (# 3, 4 #)--becomes-- x = \ $dictNum ->- let x_mono = (# fromInteger $dictNum 3, fromInteger $dictNum 4 #) in- x_mono--Note that the inner let is strict. And thus if we have a bunch of mutually-recursive bindings of this form, we could end up in trouble. This was shown-up in #9140.--But if there is a type signature on x, everything changes because of the-desugaring used by AbsBindsSig:-- x :: Num a => (# a, a #)- x = (# 3, 4 #)--becomes-- x = \ $dictNum -> (# fromInteger $dictNum 3, fromInteger $dictNum 4 #)+The function isUnliftedHsBind is used to complain if we make a top-level+binding for a variable of unlifted type. -No strictness anymore! The bottom line here is that, for inferred types, we-care about the strictness of the type after the =>. For checked types-(AbsBindsSig), we care about the overall strictness.+Such a binding is illegal if the top-level binding would be unlifted;+but also if the local letrec generated by desugaring AbsBinds would be.+E.g.+ f :: Num a => (# a, a #)+ g :: Num a => a -> a+ f = ...g...+ g = ...g... -This matters. If we don't separate out the AbsBindsSig case, then GHC runs into-a problem when compiling+The top-level bindings for f,g are not unlifted (because of the Num a =>),+but the local, recursive, monomorphic bindings are: - undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a+ t = /\a \(d:Num a).+ letrec fm :: (# a, a #) = ...g...+ gm :: a -> a = ...f...+ in (fm, gm) -Looking only after the =>, we cannot tell if this is strict or not. (GHC panics-if you try.) Looking at the whole type, on the other hand, tells you that this-is a lifted function type, with no trouble at all.+Here the binding for 'fm' is illegal. So generally we check the abe_mono types. +BUT we have a special case when abs_sig is true;+ see HsBinds Note [The abs_sig field of AbsBinds] -} ----------------- Bindings --------------------------@@ -837,63 +895,68 @@ -- bind that binds an unlifted variable, but we must be careful around -- AbsBinds. See Note [Unlifted id check in isUnliftedHsBind]. For usage -- information, see Note [Strict binds check] is DsBinds.-isUnliftedHsBind :: HsBind Id -> Bool -- works only over typechecked binds-isUnliftedHsBind (AbsBindsSig { abs_sig_export = id })- = isUnliftedType (idType id)+isUnliftedHsBind :: HsBind GhcTc -> Bool -- works only over typechecked binds isUnliftedHsBind bind+ | AbsBinds { abs_exports = exports, abs_sig = has_sig } <- bind+ = if has_sig+ then any (is_unlifted_id . abe_poly) exports+ else any (is_unlifted_id . abe_mono) exports+ -- If has_sig is True we wil never generate a binding for abe_mono,+ -- so we don't need to worry about it being unlifted. The abe_poly+ -- binding might not be: e.g. forall a. Num a => (# a, a #)++ | otherwise = any is_unlifted_id (collectHsBindBinders bind) where- is_unlifted_id id- = case tcSplitSigmaTy (idType id) of- (_, _, tau) -> isUnliftedType tau- -- For the is_unlifted check, we need to look inside polymorphism- -- and overloading. E.g. x = (# 1, True #)- -- would get type forall a. Num a => (# a, Bool #)- -- and we want to reject that. See Trac #9140+ is_unlifted_id id = isUnliftedType (idType id) --- | Is a binding a strict variable bind (e.g. @!x = ...@)?-isBangedBind :: HsBind Id -> Bool-isBangedBind b | isBangedPatBind b = True-isBangedBind (FunBind {fun_matches = matches})+-- | Is a binding a strict variable or pattern bind (e.g. @!x = ...@)?+isBangedHsBind :: HsBind GhcTc -> Bool+isBangedHsBind (AbsBinds { abs_binds = binds })+ = anyBag (isBangedHsBind . unLoc) binds+isBangedHsBind (FunBind {fun_matches = matches}) | [L _ match] <- unLoc $ mg_alts matches , FunRhs{mc_strictness = SrcStrict} <- m_ctxt match = True-isBangedBind _ = False+isBangedHsBind (PatBind {pat_lhs = pat})+ = isBangedLPat pat+isBangedHsBind _+ = False -collectLocalBinders :: HsLocalBindsLR idL idR -> [idL]+collectLocalBinders :: HsLocalBindsLR idL idR -> [IdP idL] collectLocalBinders (HsValBinds binds) = collectHsIdBinders binds -- No pattern synonyms here collectLocalBinders (HsIPBinds _) = [] collectLocalBinders EmptyLocalBinds = [] -collectHsIdBinders, collectHsValBinders :: HsValBindsLR idL idR -> [idL]+collectHsIdBinders, collectHsValBinders :: HsValBindsLR idL idR -> [IdP idL] -- Collect Id binders only, or Ids + pattern synonyms, respectively collectHsIdBinders = collect_hs_val_binders True collectHsValBinders = collect_hs_val_binders False -collectHsBindBinders :: HsBindLR idL idR -> [idL]+collectHsBindBinders :: HsBindLR idL idR -> [IdP idL] -- Collect both Ids and pattern-synonym binders collectHsBindBinders b = collect_bind False b [] -collectHsBindsBinders :: LHsBindsLR idL idR -> [idL]+collectHsBindsBinders :: LHsBindsLR idL idR -> [IdP idL] collectHsBindsBinders binds = collect_binds False binds [] -collectHsBindListBinders :: [LHsBindLR idL idR] -> [idL]+collectHsBindListBinders :: [LHsBindLR idL idR] -> [IdP idL] -- Same as collectHsBindsBinders, but works over a list of bindings collectHsBindListBinders = foldr (collect_bind False . unLoc) [] -collect_hs_val_binders :: Bool -> HsValBindsLR idL idR -> [idL]+collect_hs_val_binders :: Bool -> HsValBindsLR idL idR -> [IdP idL] collect_hs_val_binders ps (ValBindsIn binds _) = collect_binds ps binds [] collect_hs_val_binders ps (ValBindsOut binds _) = collect_out_binds ps binds -collect_out_binds :: Bool -> [(RecFlag, LHsBinds id)] -> [id]+collect_out_binds :: Bool -> [(RecFlag, LHsBinds p)] -> [IdP p] collect_out_binds ps = foldr (collect_binds ps . snd) [] -collect_binds :: Bool -> LHsBindsLR idL idR -> [idL] -> [idL]+collect_binds :: Bool -> LHsBindsLR idL idR -> [IdP idL] -> [IdP idL] -- Collect Ids, or Ids + pattern synonyms, depending on boolean flag collect_binds ps binds acc = foldrBag (collect_bind ps . unLoc) acc binds -collect_bind :: Bool -> HsBindLR idL idR -> [idL] -> [idL]+collect_bind :: Bool -> HsBindLR idL idR -> [IdP idL] -> [IdP idL] collect_bind _ (PatBind { pat_lhs = p }) acc = collect_lpat p acc collect_bind _ (FunBind { fun_id = L _ f }) acc = f : acc collect_bind _ (VarBind { var_id = f }) acc = f : acc@@ -901,12 +964,11 @@ -- I don't think we want the binders from the abe_binds -- The only time we collect binders from a typechecked -- binding (hence see AbsBinds) is in zonking in TcHsSyn-collect_bind _ (AbsBindsSig { abs_sig_export = poly }) acc = poly : acc collect_bind omitPatSyn (PatSynBind (PSB { psb_id = L _ ps })) acc | omitPatSyn = acc | otherwise = ps : acc -collectMethodBinders :: LHsBindsLR RdrName idR -> [Located RdrName]+collectMethodBinders :: LHsBindsLR GhcPs idR -> [Located RdrName] -- Used exclusively for the bindings of an instance decl which are all FunBinds collectMethodBinders binds = foldrBag (get . unLoc) [] binds where@@ -915,16 +977,16 @@ -- Someone else complains about non-FunBinds ----------------- Statements ---------------------------collectLStmtsBinders :: [LStmtLR idL idR body] -> [idL]+collectLStmtsBinders :: [LStmtLR idL idR body] -> [IdP idL] collectLStmtsBinders = concatMap collectLStmtBinders -collectStmtsBinders :: [StmtLR idL idR body] -> [idL]+collectStmtsBinders :: [StmtLR idL idR body] -> [IdP idL] collectStmtsBinders = concatMap collectStmtBinders -collectLStmtBinders :: LStmtLR idL idR body -> [idL]+collectLStmtBinders :: LStmtLR idL idR body -> [IdP idL] collectLStmtBinders = collectStmtBinders . unLoc -collectStmtBinders :: StmtLR idL idR body -> [idL]+collectStmtBinders :: StmtLR idL idR body -> [IdP idL] -- Id Binders for a Stmt... [but what about pattern-sig type vars]? collectStmtBinders (BindStmt pat _ _ _ _)= collectPatBinders pat collectStmtBinders (LetStmt (L _ binds)) = collectLocalBinders binds@@ -938,14 +1000,14 @@ ----------------- Patterns ---------------------------collectPatBinders :: LPat a -> [a]+collectPatBinders :: LPat a -> [IdP a] collectPatBinders pat = collect_lpat pat [] -collectPatsBinders :: [LPat a] -> [a]+collectPatsBinders :: [LPat a] -> [IdP a] collectPatsBinders pats = foldr collect_lpat [] pats --------------collect_lpat :: LPat name -> [name] -> [name]+collect_lpat :: LPat pass -> [IdP pass] -> [IdP pass] collect_lpat (L _ pat) bndrs = go pat where@@ -1005,14 +1067,14 @@ So in mkSelectorBinds in DsUtils, we want just m,n as the variables bound. -} -hsGroupBinders :: HsGroup Name -> [Name]+hsGroupBinders :: HsGroup GhcRn -> [Name] hsGroupBinders (HsGroup { hs_valds = val_decls, hs_tyclds = tycl_decls, hs_fords = foreign_decls }) = collectHsValBinders val_decls ++ hsTyClForeignBinders tycl_decls foreign_decls -hsTyClForeignBinders :: [TyClGroup Name]- -> [LForeignDecl Name]+hsTyClForeignBinders :: [TyClGroup GhcRn]+ -> [LForeignDecl GhcRn] -> [Name] -- We need to look at instance declarations too, -- because their associated types may bind data constructors@@ -1023,13 +1085,13 @@ `mappend` foldMap (foldMap hsLInstDeclBinders . group_instds) tycl_decls) where- getSelectorNames :: ([Located Name], [LFieldOcc Name]) -> [Name]+ getSelectorNames :: ([Located Name], [LFieldOcc GhcRn]) -> [Name] getSelectorNames (ns, fs) = map unLoc ns ++ map (selectorFieldOcc.unLoc) fs --------------------hsLTyClDeclBinders :: Located (TyClDecl name) -> ([Located name], [LFieldOcc name])+hsLTyClDeclBinders :: Located (TyClDecl pass)+ -> ([Located (IdP pass)], [LFieldOcc pass]) -- ^ Returns all the /binding/ names of the decl. The first one is- -- guaranteed to be the name of the decl. The first component -- represents all binding names except record fields; the second -- represents field occurrences. For record fields mentioned in@@ -1051,7 +1113,7 @@ = (\ (xs, ys) -> (L loc name : xs, ys)) $ hsDataDefnBinders defn --------------------hsForeignDeclsBinders :: [LForeignDecl name] -> [Located name]+hsForeignDeclsBinders :: [LForeignDecl pass] -> [Located (IdP pass)] -- See Note [SrcSpan for binders] hsForeignDeclsBinders foreign_decls = [ L decl_loc n@@ -1059,16 +1121,16 @@ --------------------hsPatSynSelectors :: HsValBinds id -> [id]+hsPatSynSelectors :: HsValBinds p -> [IdP p] -- Collects record pattern-synonym selectors only; the pattern synonym -- names are collected by collectHsValBinders. hsPatSynSelectors (ValBindsIn _ _) = panic "hsPatSynSelectors" hsPatSynSelectors (ValBindsOut binds _) = foldrBag addPatSynSelector [] . unionManyBags $ map snd binds -addPatSynSelector:: LHsBind id -> [id] -> [id]+addPatSynSelector:: LHsBind p -> [IdP p] -> [IdP p] addPatSynSelector bind sels- | L _ (PatSynBind (PSB { psb_args = RecordPatSyn as })) <- bind+ | L _ (PatSynBind (PSB { psb_args = RecCon as })) <- bind = map (unLoc . recordPatSynSelectorId) as ++ sels | otherwise = sels @@ -1078,7 +1140,8 @@ , L _ (PatSynBind psb) <- bagToList lbinds ] --------------------hsLInstDeclBinders :: LInstDecl name -> ([Located name], [LFieldOcc name])+hsLInstDeclBinders :: LInstDecl pass+ -> ([Located (IdP pass)], [LFieldOcc pass]) hsLInstDeclBinders (L _ (ClsInstD { cid_inst = ClsInstDecl { cid_datafam_insts = dfis } })) = foldMap (hsDataFamInstBinders . unLoc) dfis hsLInstDeclBinders (L _ (DataFamInstD { dfid_inst = fi }))@@ -1087,26 +1150,28 @@ ------------------- -- the SrcLoc returned are for the whole declarations, not just the names-hsDataFamInstBinders :: DataFamInstDecl name -> ([Located name], [LFieldOcc name])-hsDataFamInstBinders (DataFamInstDecl { dfid_defn = defn })+hsDataFamInstBinders :: DataFamInstDecl pass+ -> ([Located (IdP pass)], [LFieldOcc pass])+hsDataFamInstBinders (DataFamInstDecl { dfid_eqn = HsIB { hsib_body =+ FamEqn { feqn_rhs = defn }}}) = hsDataDefnBinders defn -- There can't be repeated symbols because only data instances have binders ------------------- -- the SrcLoc returned are for the whole declarations, not just the names-hsDataDefnBinders :: HsDataDefn name -> ([Located name], [LFieldOcc name])+hsDataDefnBinders :: HsDataDefn pass -> ([Located (IdP pass)], [LFieldOcc pass]) hsDataDefnBinders (HsDataDefn { dd_cons = cons }) = hsConDeclsBinders cons -- See Note [Binders in family instances] --------------------hsConDeclsBinders :: [LConDecl name] -> ([Located name], [LFieldOcc name])+hsConDeclsBinders :: [LConDecl pass] -> ([Located (IdP pass)], [LFieldOcc pass]) -- See hsLTyClDeclBinders for what this does -- The function is boringly complicated because of the records -- And since we only have equality, we have to be a little careful hsConDeclsBinders cons = go id cons- where go :: ([LFieldOcc name] -> [LFieldOcc name])- -> [LConDecl name] -> ([Located name], [LFieldOcc name])+ where go :: ([LFieldOcc pass] -> [LFieldOcc pass])+ -> [LConDecl pass] -> ([Located (IdP pass)], [LFieldOcc pass]) go _ [] = ([], []) go remSeen (r:rs) = -- don't re-mangle the location of field names, because we don't@@ -1182,16 +1247,16 @@ warning the user when they don't use those names (#4404) -} -lStmtsImplicits :: [LStmtLR Name idR (Located (body idR))] -> NameSet+lStmtsImplicits :: [LStmtLR GhcRn idR (Located (body idR))] -> NameSet lStmtsImplicits = hs_lstmts where- hs_lstmts :: [LStmtLR Name idR (Located (body idR))] -> NameSet+ hs_lstmts :: [LStmtLR GhcRn idR (Located (body idR))] -> NameSet hs_lstmts = foldr (\stmt rest -> unionNameSet (hs_stmt (unLoc stmt)) rest) emptyNameSet - hs_stmt :: StmtLR Name idR (Located (body idR)) -> NameSet+ hs_stmt :: StmtLR GhcRn idR (Located (body idR)) -> NameSet hs_stmt (BindStmt pat _ _ _ _) = lPatImplicits pat hs_stmt (ApplicativeStmt args _ _) = unionNameSets (map do_arg args)- where do_arg (_, ApplicativeArgOne pat _) = lPatImplicits pat+ where do_arg (_, ApplicativeArgOne pat _ _) = lPatImplicits pat do_arg (_, ApplicativeArgMany stmts _ _) = hs_lstmts stmts hs_stmt (LetStmt binds) = hs_local_binds (unLoc binds) hs_stmt (BodyStmt {}) = emptyNameSet@@ -1204,19 +1269,19 @@ hs_local_binds (HsIPBinds _) = emptyNameSet hs_local_binds EmptyLocalBinds = emptyNameSet -hsValBindsImplicits :: HsValBindsLR Name idR -> NameSet+hsValBindsImplicits :: HsValBindsLR GhcRn idR -> NameSet hsValBindsImplicits (ValBindsOut binds _) = foldr (unionNameSet . lhsBindsImplicits . snd) emptyNameSet binds hsValBindsImplicits (ValBindsIn binds _) = lhsBindsImplicits binds -lhsBindsImplicits :: LHsBindsLR Name idR -> NameSet+lhsBindsImplicits :: LHsBindsLR GhcRn idR -> NameSet lhsBindsImplicits = foldBag unionNameSet (lhs_bind . unLoc) emptyNameSet where lhs_bind (PatBind { pat_lhs = lpat }) = lPatImplicits lpat lhs_bind _ = emptyNameSet -lPatImplicits :: LPat Name -> NameSet+lPatImplicits :: LPat GhcRn -> NameSet lPatImplicits = hs_lpat where hs_lpat (L _ pat) = hs_pat pat
hsSyn/PlaceHolder.hs view
@@ -6,20 +6,16 @@ module PlaceHolder where +import GhcPrelude ()+ import Type ( Type ) import Outputable import Name import NameSet import RdrName import Var-import Coercion-import ConLike (ConLike)-import FieldLabel-import SrcLoc (Located)-import TcEvidence ( HsWrapper ) import Data.Data hiding ( Fixity )-import BasicTypes (Fixity) {-@@ -37,18 +33,6 @@ data PlaceHolder = PlaceHolder deriving (Data) --- | Types that are not defined until after type checking-type family PostTc id ty -- Note [Pass sensitive types]-type instance PostTc Id ty = ty-type instance PostTc Name ty = PlaceHolder-type instance PostTc RdrName ty = PlaceHolder---- | Types that are not defined until after renaming-type family PostRn id ty -- Note [Pass sensitive types]-type instance PostRn Id ty = ty-type instance PostRn Name ty = ty-type instance PostRn RdrName ty = PlaceHolder- placeHolderKind :: PlaceHolder placeHolderKind = PlaceHolder @@ -103,42 +87,10 @@ UndecidableInstances pragma is required where this is used. -} -type DataId id =- ( DataIdPost id- , DataIdPost (NameOrRdrName id)- ) -type DataIdPost id =- ( Data id- , Data (PostRn id NameSet)- , Data (PostRn id Fixity)- , Data (PostRn id Bool)- , Data (PostRn id Name)- , Data (PostRn id (Located Name))- , Data (PostRn id [Name])-- , Data (PostRn id id)- , Data (PostTc id Type)- , Data (PostTc id Coercion)- , Data (PostTc id id)- , Data (PostTc id [Type])- , Data (PostTc id ConLike)- , Data (PostTc id [ConLike])- , Data (PostTc id HsWrapper)- , Data (PostTc id [FieldLabel])- )-- -- |Follow the @id@, but never beyond Name. This is used in a 'HsMatchContext', -- for printing messages related to a 'Match' type family NameOrRdrName id where NameOrRdrName Id = Name NameOrRdrName Name = Name NameOrRdrName RdrName = RdrName---- |Constraint type to bundle up the requirement for 'OutputableBndr' on both--- the @id@ and the 'NameOrRdrName' type for it-type OutputableBndrId id =- ( OutputableBndr id- , OutputableBndr (NameOrRdrName id)- )
iface/BinFingerprint.hs view
@@ -10,6 +10,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Fingerprint import Binary import Name
iface/BinIface.hs view
@@ -1,10 +1,10 @@-{-# LANGUAGE BinaryLiterals, CPP, ScopedTypeVariables #-}+{-# LANGUAGE BinaryLiterals, CPP, ScopedTypeVariables, BangPatterns #-} -- -- (c) The University of Glasgow 2002-2006 -- -{-# OPTIONS_GHC -O #-}+{-# OPTIONS_GHC -O2 #-} -- We always optimise this, otherwise performance of a non-optimised -- compiler is severely affected @@ -20,6 +20,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TcRnMonad import PrelInfo ( isKnownKeyName, lookupKnownKeyName ) import IfaceEnv@@ -42,14 +44,18 @@ import Constants import Util +import Data.Array+import Data.Array.ST+import Data.Array.Unsafe import Data.Bits import Data.Char-import Data.List import Data.Word-import Data.Array import Data.IORef+import Data.Foldable import Control.Monad-+import Control.Monad.ST+import Control.Monad.Trans.Class+import qualified Control.Monad.Trans.State.Strict as State -- --------------------------------------------------------------------------- -- Reading and writing binary interface files@@ -259,15 +265,24 @@ sz <- get bh od_names <- sequence (replicate sz (get bh)) updateNameCache ncu $ \namecache ->- let arr = listArray (0,sz-1) names- (namecache', names) =- mapAccumR (fromOnDiskName arr) namecache od_names- in (namecache', arr)+ runST $ flip State.evalStateT namecache $ do+ mut_arr <- lift $ newSTArray_ (0, sz-1)+ for_ (zip [0..] od_names) $ \(i, odn) -> do+ (nc, !n) <- State.gets $ \nc -> fromOnDiskName nc odn+ lift $ writeArray mut_arr i n+ State.put nc+ arr <- lift $ unsafeFreeze mut_arr+ namecache' <- State.get+ return (namecache', arr)+ where+ -- This binding is required because the type of newArray_ cannot be inferred+ newSTArray_ :: forall s. (Int, Int) -> ST s (STArray s Int Name)+ newSTArray_ = newArray_ type OnDiskName = (UnitId, ModuleName, OccName) -fromOnDiskName :: Array Int Name -> NameCache -> OnDiskName -> (NameCache, Name)-fromOnDiskName _ nc (pid, mod_name, occ) =+fromOnDiskName :: NameCache -> OnDiskName -> (NameCache, Name)+fromOnDiskName nc (pid, mod_name, occ) = let mod = mkModule pid mod_name cache = nsNames nc in case lookupOrigNameCache cache mod occ of
iface/BuildTyCl.hs view
@@ -6,7 +6,7 @@ {-# LANGUAGE CPP #-} module BuildTyCl (- buildDataCon, mkDataConUnivTyVarBinders,+ buildDataCon, buildPatSyn, TcMethInfo, buildClass, mkNewTyConRhs, mkDataTyConRhs,@@ -15,6 +15,8 @@ #include "HsVersions.h" +import GhcPrelude+ import IfaceEnv import FamInstEnv( FamInstEnvs, mkNewTypeCoAxiom ) import TysWiredIn( isCTupleTyConName )@@ -70,9 +72,12 @@ where tvs = tyConTyVars tycon roles = tyConRoles tycon- inst_con_ty = piResultTys (dataConUserType con) (mkTyVarTys tvs)- rhs_ty = ASSERT( isFunTy inst_con_ty ) funArgTy inst_con_ty- -- Instantiate the data con with the+ con_arg_ty = case dataConRepArgTys con of+ [arg_ty] -> arg_ty+ tys -> pprPanic "mkNewTyConRhs" (ppr con <+> ppr tys)+ rhs_ty = substTyWith (dataConUnivTyVars con)+ (mkTyVarTys tvs) con_arg_ty+ -- Instantiate the newtype's RHS with the -- type variables from the tycon -- NB: a newtype DataCon has a type that must look like -- forall tvs. <arg-ty> -> T tvs@@ -107,8 +112,9 @@ -> Maybe [HsImplBang] -- See Note [Bangs on imported data constructors] in MkId -> [FieldLabel] -- Field labels- -> [TyVarBinder] -- Universals- -> [TyVarBinder] -- Existentials+ -> [TyVar] -- Universals+ -> [TyVar] -- Existentials+ -> [TyVarBinder] -- User-written 'TyVarBinder's -> [EqSpec] -- Equality spec -> ThetaType -- Does not include the "stupid theta" -- or the GADT equalities@@ -119,9 +125,8 @@ -- a) makes the worker Id -- b) makes the wrapper Id if necessary, including -- allocating its unique (hence monadic)--- c) Sorts out the TyVarBinders. See mkDataConUnivTyBinders buildDataCon fam_envs src_name declared_infix prom_info src_bangs impl_bangs field_lbls- univ_tvs ex_tvs eq_spec ctxt arg_tys res_ty rep_tycon+ univ_tvs ex_tvs user_tvbs eq_spec ctxt arg_tys res_ty rep_tycon = do { wrap_name <- newImplicitBinder src_name mkDataConWrapperOcc ; work_name <- newImplicitBinder src_name mkDataConWorkerOcc -- This last one takes the name of the data constructor in the source@@ -134,7 +139,7 @@ ; let stupid_ctxt = mkDataConStupidTheta rep_tycon arg_tys univ_tvs data_con = mkDataCon src_name declared_infix prom_info src_bangs field_lbls- univ_tvs ex_tvs eq_spec ctxt+ univ_tvs ex_tvs user_tvbs eq_spec ctxt arg_tys res_ty NoRRI rep_tycon stupid_ctxt dc_wrk dc_rep dc_wrk = mkDataConWorkId work_name data_con@@ -149,13 +154,13 @@ -- the type variables mentioned in the arg_tys -- ToDo: Or functionally dependent on? -- This whole stupid theta thing is, well, stupid.-mkDataConStupidTheta :: TyCon -> [Type] -> [TyVarBinder] -> [PredType]+mkDataConStupidTheta :: TyCon -> [Type] -> [TyVar] -> [PredType] mkDataConStupidTheta tycon arg_tys univ_tvs | null stupid_theta = [] -- The common case | otherwise = filter in_arg_tys stupid_theta where tc_subst = zipTvSubst (tyConTyVars tycon)- (mkTyVarTys (binderVars univ_tvs))+ (mkTyVarTys univ_tvs) stupid_theta = substTheta tc_subst (tyConStupidTheta tycon) -- Start by instantiating the master copy of the -- stupid theta, taken from the TyCon@@ -165,69 +170,6 @@ tyCoVarsOfType pred `intersectVarSet` arg_tyvars -mkDataConUnivTyVarBinders :: [TyConBinder] -- From the TyCon- -> [TyVarBinder] -- For the DataCon--- See Note [Building the TyBinders for a DataCon]-mkDataConUnivTyVarBinders tc_bndrs- = map mk_binder tc_bndrs- where- mk_binder (TvBndr tv tc_vis) = mkTyVarBinder vis tv- where- vis = case tc_vis of- AnonTCB -> Specified- NamedTCB Required -> Specified- NamedTCB vis -> vis--{- Note [Building the TyBinders for a DataCon]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A DataCon needs to keep track of the visibility of its universals and-existentials, so that visible type application can work properly. This-is done by storing the universal and existential TyVarBinders.-See Note [TyVarBinders in DataCons] in DataCon.--During construction of a DataCon, we often start from the TyBinders of-the parent TyCon. For example- data Maybe a = Nothing | Just a-The DataCons start from the TyBinders of the parent TyCon.--But the ultimate TyBinders for the DataCon are *different* than those-of the DataCon. Here is an example:-- data App a b = MkApp (a b) -- App :: forall {k}. (k->*) -> k -> *--The TyCon has-- tyConTyVars = [ k:*, a:k->*, b:k]- tyConTyBinders = [ Named (TvBndr (k :: *) Inferred), Anon (k->*), Anon k ]--The TyBinders for App line up with App's kind, given above.--But the DataCon MkApp has the type- MkApp :: forall {k} (a:k->*) (b:k). a b -> App k a b--That is, its TyBinders should be-- dataConUnivTyVarBinders = [ TvBndr (k:*) Inferred- , TvBndr (a:k->*) Specified- , TvBndr (b:k) Specified ]--So we want to take the TyCon's TyBinders and the TyCon's TyVars and-merge them, pulling- - variable names from the TyVars- - visibilities from the TyBinders- - but changing Anon/Required to Specified--The last part about Required->Specified comes from this:- data T k (a:k) b = MkT (a b)-Here k is Required in T's kind, but we don't have Required binders in-the TyBinders for a term (see Note [No Required TyBinder in terms]-in TyCoRep), so we change it to Specified when making MkT's TyBinders--This merging operation is done by mkDataConUnivTyBinders. In contrast,-the TyBinders passed to mkDataCon are the final TyBinders stored in the-DataCon (mkDataCon does no further work).--}- ------------------------------------------------------ buildPatSyn :: Name -> Bool -> (Id,Bool) -> Maybe (Id, Bool)@@ -310,7 +252,7 @@ do { traceIf (text "buildClass") ; tc_rep_name <- newTyConRepName tycon_name- ; let univ_bndrs = mkDataConUnivTyVarBinders binders+ ; let univ_bndrs = tyConTyVarBinders binders univ_tvs = binderVars univ_bndrs tycon = mkClassTyCon tycon_name binders roles AbstractTyCon rec_clas tc_rep_name@@ -359,7 +301,7 @@ op_names = [op | (op,_,_) <- sig_stuff] arg_tys = sc_theta ++ op_tys rec_tycon = classTyCon rec_clas- univ_bndrs = mkDataConUnivTyVarBinders binders+ univ_bndrs = tyConTyVarBinders binders univ_tvs = binderVars univ_bndrs ; rep_nm <- newTyConRepName datacon_name@@ -370,8 +312,9 @@ (map (const no_bang) args) (Just (map (const HsLazy) args)) [{- No fields -}]- univ_bndrs+ univ_tvs [{- no existentials -}]+ univ_bndrs [{- No GADT equalities -}] [{- No theta -}] arg_tys
iface/FlagChecker.hs view
@@ -4,8 +4,12 @@ -- interface file as part of the recompilation checking infrastructure. module FlagChecker ( fingerprintDynFlags+ , fingerprintOptFlags+ , fingerprintHpcFlags ) where +import GhcPrelude+ import Binary import BinIface () import DynFlags@@ -16,7 +20,7 @@ import BinFingerprint -- import Outputable -import qualified Data.IntSet as IntSet+import qualified EnumSet import System.FilePath (normalise) -- | Produce a fingerprint of a @DynFlags@ value. We only base@@ -39,7 +43,7 @@ -- *all* the extension flags and the language lang = (fmap fromEnum language,- IntSet.toList $ extensionFlags)+ map fromEnum $ EnumSet.toList extensionFlags) -- -I, -D and -U flags affect CPP cpp = (map normalise includePaths, opt_P dflags ++ picPOpts dflags)@@ -51,21 +55,45 @@ -- -fprof-auto etc. prof = if gopt Opt_SccProfilingOn dflags then fromEnum profAuto else 0 - -- -O, see https://ghc.haskell.org/trac/ghc/ticket/10923- opt = if hscTarget == HscInterpreted ||- hscTarget == HscNothing- then 0- else optLevel+ flags = (mainis, safeHs, lang, cpp, paths, prof) + in -- pprTrace "flags" (ppr flags) $+ computeFingerprint nameio flags++-- Fingerprint the optimisation info. We keep this separate from the rest of+-- the flags because GHCi users (especially) may wish to ignore changes in+-- optimisation level or optimisation flags so as to use as many pre-existing+-- object files as they can.+-- See Note [Ignoring some flag changes]+fingerprintOptFlags :: DynFlags+ -> (BinHandle -> Name -> IO ())+ -> IO Fingerprint+fingerprintOptFlags DynFlags{..} nameio =+ let+ -- See https://ghc.haskell.org/trac/ghc/ticket/10923+ -- We used to fingerprint the optimisation level, but as Joachim+ -- Breitner pointed out in comment 9 on that ticket, it's better+ -- to ignore that and just look at the individual optimisation flags.+ opt_flags = map fromEnum $ filter (`EnumSet.member` optimisationFlags)+ (EnumSet.toList generalFlags)++ in computeFingerprint nameio opt_flags++-- Fingerprint the HPC info. We keep this separate from the rest of+-- the flags because GHCi users (especially) may wish to use an object+-- file compiled for HPC when not actually using HPC.+-- See Note [Ignoring some flag changes]+fingerprintHpcFlags :: DynFlags+ -> (BinHandle -> Name -> IO ())+ -> IO Fingerprint+fingerprintHpcFlags dflags@DynFlags{..} nameio =+ let -- -fhpc, see https://ghc.haskell.org/trac/ghc/ticket/11798 -- hpcDir is output-only, so we should recompile if it changes hpc = if gopt Opt_Hpc dflags then Just hpcDir else Nothing - -- Nesting just to avoid ever more Binary tuple instances- flags = (mainis, safeHs, lang, cpp, paths, (prof, opt, hpc))+ in computeFingerprint nameio hpc - in -- pprTrace "flags" (ppr flags) $- computeFingerprint nameio flags {- Note [path flags and recompilation] @@ -95,4 +123,23 @@ files; we don't want this to force recompilation. The only path-related flag left is -hcsuf.+-}++{- Note [Ignoring some flag changes]+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++Normally, --make tries to reuse only compilation products that are+the same as those that would have been produced compiling from+scratch. Sometimes, however, users would like to be more aggressive+about recompilation avoidance. This is particularly likely when+developing using GHCi (see #13604). Currently, we allow users to+ignore optimisation changes using -fignore-optim-changes, and to+ignore HPC option changes using -fignore-hpc-changes. If there's a+demand for it, we could also allow changes to -fprof-auto-* flags+(although we can't allow -prof flags to differ). The key thing about+these options is that we can still successfully link a library or+executable when some of its components differ in these ways.++The way we accomplish this is to leave the optimization and HPC+options out of the flag hash, hashing them separately. -}
iface/IfaceEnv.hs view
@@ -22,6 +22,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TcRnMonad import HscTypes import Type@@ -143,7 +145,7 @@ -} -- | Look up the 'Name' for a given 'Module' and 'OccName'.--- Consider alternately using 'lookupIfaceTop' if you're in the 'IfL' monad+-- Consider alternatively using 'lookupIfaceTop' if you're in the 'IfL' monad -- and 'Module' is simply that of the 'ModIface' you are typechecking. lookupOrig :: Module -> OccName -> TcRnIf a b Name lookupOrig mod occ
iface/IfaceSyn.hs view
@@ -41,6 +41,8 @@ #include "HsVersions.h" +import GhcPrelude+ import IfaceType import BinFingerprint import CoreSyn( IsOrphan, isOrphan )@@ -64,13 +66,13 @@ import BooleanFormula ( BooleanFormula, pprBooleanFormula, isTrue ) import Var( TyVarBndr(..) ) import TyCon ( Role (..), Injectivity(..) )-import Util( filterOut, filterByList )+import Util( dropList, filterByList ) import DataCon (SrcStrictness(..), SrcUnpackedness(..)) import Lexeme (isLexSym)+import DynFlags import Control.Monad import System.IO.Unsafe-import Data.Maybe (isJust) infixl 3 &&& @@ -85,7 +87,7 @@ -- | A binding top-level 'Name' in an interface file (e.g. the name of an -- 'IfaceDecl'). type IfaceTopBndr = Name- -- It's convenient to have an Name in the IfaceSyn, although in each+ -- It's convenient to have a Name in the IfaceSyn, although in each -- case the namespace is implied by the context. However, having an -- Name makes things like ifaceDeclImplicitBndrs and ifaceDeclFingerprints -- very convenient. Moreover, having the key of the binder means that@@ -238,7 +240,14 @@ -- but it's not so easy for the original TyCon/DataCon -- So this guarantee holds for IfaceConDecl, but *not* for DataCon - ifConExTvs :: [IfaceForAllBndr], -- Existential tyvars (w/ visibility)+ ifConExTvs :: [IfaceTvBndr], -- Existential tyvars+ ifConUserTvBinders :: [IfaceForAllBndr],+ -- The tyvars, in the order the user wrote them+ -- INVARIANT: the set of tyvars in ifConUserTvBinders is exactly the+ -- set of ifConExTvs, unioned with the set of ifBinders+ -- (from the parent IfaceDecl) whose tyvars do not appear+ -- in ifConEqSpec+ -- See Note [DataCon user type variable binders] in DataCon ifConEqSpec :: IfaceEqSpec, -- Equality constraints ifConCtxt :: IfaceContext, -- Non-stupid context ifConArgTys :: [IfaceType], -- Arg types@@ -554,7 +563,10 @@ $+$ nest 2 maybe_incomps where- ppr_binders+ ppr_binders = sdocWithDynFlags $ \dflags ->+ ppWhen (gopt Opt_PrintExplicitForalls dflags) ppr_binders'++ ppr_binders' | null tvs && null cvs = empty | null cvs = brackets (pprWithCommas (pprIfaceTvBndr True) tvs)@@ -688,26 +700,28 @@ -- NB: pprIfaceDecl is also used for pretty-printing TyThings in GHCi -- See Note [Pretty-printing TyThings] in PprTyThing pprIfaceDecl ss (IfaceData { ifName = tycon, ifCType = ctype,- ifCtxt = context,+ ifCtxt = context, ifResKind = kind, ifRoles = roles, ifCons = condecls, ifParent = parent, ifGadtSyntax = gadt, ifBinders = binders }) - | gadt_style = vcat [ pp_roles- , pp_nd <+> pp_lhs <+> pp_where- , nest 2 (vcat pp_cons)- , nest 2 $ ppShowIface ss pp_extra ]- | otherwise = vcat [ pp_roles- , hang (pp_nd <+> pp_lhs) 2 (add_bars pp_cons)- , nest 2 $ ppShowIface ss pp_extra ]+ | gadt = vcat [ pp_roles+ , pp_nd <+> pp_lhs <+> pp_kind <+> pp_where+ , nest 2 (vcat pp_cons)+ , nest 2 $ ppShowIface ss pp_extra ]+ | otherwise = vcat [ pp_roles+ , hang (pp_nd <+> pp_lhs <+> pp_kind) 2 (add_bars pp_cons)+ , nest 2 $ ppShowIface ss pp_extra ] where is_data_instance = isIfaceDataInstance parent - gadt_style = gadt || any (not . isVanillaIfaceConDecl) cons cons = visibleIfConDecls condecls- pp_where = ppWhen (gadt_style && not (null cons)) $ text "where"+ pp_where = ppWhen (gadt && not (null cons)) $ text "where" pp_cons = ppr_trim (map show_con cons) :: [SDoc]+ pp_kind+ | isIfaceLiftedTypeKind kind = empty+ | otherwise = dcolon <+> ppr kind pp_lhs = case parent of IfNoParent -> pprIfaceDeclHead context ss tycon binders Nothing@@ -729,7 +743,7 @@ ok_con dc = showSub ss dc || any (showSub ss . flSelector) (ifConFields dc) show_con dc- | ok_con dc = Just $ pprIfaceConDecl ss gadt_style tycon binders parent dc+ | ok_con dc = Just $ pprIfaceConDecl ss gadt tycon binders parent dc | otherwise = Nothing pp_nd = case condecls of@@ -950,12 +964,6 @@ <+> pprIfaceTyConBinders (suppressIfaceInvisibles dflags bndrs bndrs) , maybe empty (\res_kind -> dcolon <+> pprIfaceType res_kind) m_res_kind ] -isVanillaIfaceConDecl :: IfaceConDecl -> Bool-isVanillaIfaceConDecl (IfCon { ifConExTvs = ex_tvs- , ifConEqSpec = eq_spec- , ifConCtxt = ctxt })- = (null ex_tvs) && (null eq_spec) && (null ctxt)- pprIfaceConDecl :: ShowSub -> Bool -> IfaceTopBndr -> [IfaceTyConBinder]@@ -963,44 +971,61 @@ -> IfaceConDecl -> SDoc pprIfaceConDecl ss gadt_style tycon tc_binders parent (IfCon { ifConName = name, ifConInfix = is_infix,- ifConExTvs = ex_tvs,+ ifConUserTvBinders = user_tvbs, ifConEqSpec = eq_spec, ifConCtxt = ctxt, ifConArgTys = arg_tys, ifConStricts = stricts, ifConFields = fields })- | gadt_style = pp_prefix_con <+> dcolon <+> ppr_ty- | not (null fields) = pp_prefix_con <+> pp_field_args- | is_infix- , [ty1, ty2] <- pp_args = sep [ ty1- , pprInfixIfDeclBndr how_much (occName name)- , ty2]-- | otherwise = pp_prefix_con <+> sep pp_args+ | gadt_style = pp_prefix_con <+> dcolon <+> ppr_gadt_ty+ | otherwise = ppr_ex_quant pp_h98_con where+ pp_h98_con+ | not (null fields) = pp_prefix_con <+> pp_field_args+ | is_infix+ , [ty1, ty2] <- pp_args+ = sep [ ty1+ , pprInfixIfDeclBndr how_much (occName name)+ , ty2]+ | otherwise = pp_prefix_con <+> sep pp_args+ how_much = ss_how_much ss tys_w_strs :: [(IfaceBang, IfaceType)] tys_w_strs = zip stricts arg_tys pp_prefix_con = pprPrefixIfDeclBndr how_much (occName name) - (univ_tvs, pp_res_ty) = mk_user_con_res_ty eq_spec- ppr_ty = pprIfaceForAllPart (map tv_to_forall_bndr univ_tvs ++ ex_tvs)- ctxt pp_tau+ -- If we're pretty-printing a H98-style declaration with existential+ -- quantification, then user_tvbs will always consist of the universal+ -- tyvar binders followed by the existential tyvar binders. So to recover+ -- the visibilities of the existential tyvar binders, we can simply drop+ -- the universal tyvar binders from user_tvbs.+ ex_tvbs = dropList tc_binders user_tvbs+ ppr_ex_quant = pprIfaceForAllPartMust ex_tvbs ctxt+ pp_gadt_res_ty = mk_user_con_res_ty eq_spec+ ppr_gadt_ty = pprIfaceForAllPart user_tvbs ctxt pp_tau -- A bit gruesome this, but we can't form the full con_tau, and ppr it, -- because we don't have a Name for the tycon, only an OccName pp_tau | null fields- = case pp_args ++ [pp_res_ty] of+ = case pp_args ++ [pp_gadt_res_ty] of (t:ts) -> fsep (t : map (arrow <+>) ts) [] -> panic "pp_con_taus" | otherwise- = sep [pp_field_args, arrow <+> pp_res_ty]+ = sep [pp_field_args, arrow <+> pp_gadt_res_ty] - ppr_bang IfNoBang = sdocWithPprDebug $ \dbg -> ppWhen dbg $ char '_'+ ppr_bang IfNoBang = whenPprDebug $ char '_' ppr_bang IfStrict = char '!' ppr_bang IfUnpack = text "{-# UNPACK #-}" ppr_bang (IfUnpackCo co) = text "! {-# UNPACK #-}" <> pprParendIfaceCoercion co pprParendBangTy (bang, ty) = ppr_bang bang <> pprParendIfaceType ty- pprBangTy (bang, ty) = ppr_bang bang <> ppr ty+ pprBangTy (bang, ty) = ppr_bang bang <> ppr_banged_ty ty+ where+ -- The presence of bang patterns or UNPACK annotations requires+ -- surrounding the type with parentheses, if needed (#13699)+ ppr_banged_ty = case bang of+ IfNoBang -> ppr+ IfStrict -> pprParendIfaceType+ IfUnpack -> pprParendIfaceType+ IfUnpackCo{} -> pprParendIfaceType pp_args :: [SDoc] -- With parens, e.g (Maybe a) or !(Maybe a) pp_args = map pprParendBangTy tys_w_strs@@ -1019,17 +1044,15 @@ sel = flSelector lbl occ = mkVarOccFS (flLabel lbl) - mk_user_con_res_ty :: IfaceEqSpec -> ([IfaceTvBndr], SDoc)+ mk_user_con_res_ty :: IfaceEqSpec -> SDoc -- See Note [Result type of a data family GADT] mk_user_con_res_ty eq_spec | IfDataInstance _ tc tys <- parent- = (con_univ_tvs, pprIfaceType (IfaceTyConApp tc (substIfaceTcArgs gadt_subst tys)))+ = pprIfaceType (IfaceTyConApp tc (substIfaceTcArgs gadt_subst tys)) | otherwise- = (con_univ_tvs, sdocWithDynFlags (ppr_tc_app gadt_subst))+ = sdocWithDynFlags (ppr_tc_app gadt_subst) where- gadt_subst = mkFsEnv eq_spec- done_univ_tv (tv,_) = isJust (lookupFsEnv gadt_subst tv)- con_univ_tvs = filterOut done_univ_tv (map ifTyConBinderTyVar tc_binders)+ gadt_subst = mkIfaceTySubst eq_spec ppr_tc_app gadt_subst dflags = pprPrefixIfDeclBndr how_much (occName tycon)@@ -1071,9 +1094,6 @@ ppr_rough Nothing = dot ppr_rough (Just tc) = ppr tc -tv_to_forall_bndr :: IfaceTvBndr -> IfaceForAllBndr-tv_to_forall_bndr tv = TvBndr tv Specified- {- Note [Result type of a data family GADT] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1258,45 +1278,66 @@ -} freeNamesIfDecl :: IfaceDecl -> NameSet-freeNamesIfDecl (IfaceId _s t d i) =- freeNamesIfType t &&&- freeNamesIfIdInfo i &&&- freeNamesIfIdDetails d-freeNamesIfDecl d@IfaceData{} =- freeNamesIfTyVarBndrs (ifBinders d) &&&- freeNamesIfType (ifResKind d) &&&- freeNamesIfaceTyConParent (ifParent d) &&&- freeNamesIfContext (ifCtxt d) &&&- freeNamesIfConDecls (ifCons d)-freeNamesIfDecl d@IfaceSynonym{} =- freeNamesIfType (ifSynRhs d) &&&- freeNamesIfTyVarBndrs (ifBinders d) &&&- freeNamesIfKind (ifResKind d)-freeNamesIfDecl d@IfaceFamily{} =- freeNamesIfFamFlav (ifFamFlav d) &&&- freeNamesIfTyVarBndrs (ifBinders d) &&&- freeNamesIfKind (ifResKind d)-freeNamesIfDecl d@IfaceClass{ ifBody = IfAbstractClass } =- freeNamesIfTyVarBndrs (ifBinders d)-freeNamesIfDecl d@IfaceClass{ ifBody = d'@IfConcreteClass{} } =- freeNamesIfTyVarBndrs (ifBinders d) &&&- freeNamesIfContext (ifClassCtxt d') &&&- fnList freeNamesIfAT (ifATs d') &&&- fnList freeNamesIfClsSig (ifSigs d')-freeNamesIfDecl d@IfaceAxiom{} =- freeNamesIfTc (ifTyCon d) &&&- fnList freeNamesIfAxBranch (ifAxBranches d)-freeNamesIfDecl d@IfacePatSyn{} =- unitNameSet (fst (ifPatMatcher d)) &&&- maybe emptyNameSet (unitNameSet . fst) (ifPatBuilder d) &&&- freeNamesIfTyVarBndrs (ifPatUnivBndrs d) &&&- freeNamesIfTyVarBndrs (ifPatExBndrs d) &&&- freeNamesIfContext (ifPatProvCtxt d) &&&- freeNamesIfContext (ifPatReqCtxt d) &&&- fnList freeNamesIfType (ifPatArgs d) &&&- freeNamesIfType (ifPatTy d) &&&- mkNameSet (map flSelector (ifFieldLabels d))+freeNamesIfDecl (IfaceId { ifType = t, ifIdDetails = d, ifIdInfo = i})+ = freeNamesIfType t &&&+ freeNamesIfIdInfo i &&&+ freeNamesIfIdDetails d +freeNamesIfDecl (IfaceData { ifBinders = bndrs, ifResKind = res_k+ , ifParent = p, ifCtxt = ctxt, ifCons = cons })+ = freeNamesIfTyVarBndrs bndrs &&&+ freeNamesIfType res_k &&&+ freeNamesIfaceTyConParent p &&&+ freeNamesIfContext ctxt &&&+ freeNamesIfConDecls cons++freeNamesIfDecl (IfaceSynonym { ifBinders = bndrs, ifResKind = res_k+ , ifSynRhs = rhs })+ = freeNamesIfTyVarBndrs bndrs &&&+ freeNamesIfKind res_k &&&+ freeNamesIfType rhs++freeNamesIfDecl (IfaceFamily { ifBinders = bndrs, ifResKind = res_k+ , ifFamFlav = flav })+ = freeNamesIfTyVarBndrs bndrs &&&+ freeNamesIfKind res_k &&&+ freeNamesIfFamFlav flav++freeNamesIfDecl (IfaceClass{ ifBinders = bndrs, ifBody = cls_body })+ = freeNamesIfTyVarBndrs bndrs &&&+ freeNamesIfClassBody cls_body++freeNamesIfDecl (IfaceAxiom { ifTyCon = tc, ifAxBranches = branches })+ = freeNamesIfTc tc &&&+ fnList freeNamesIfAxBranch branches++freeNamesIfDecl (IfacePatSyn { ifPatMatcher = (matcher, _)+ , ifPatBuilder = mb_builder+ , ifPatUnivBndrs = univ_bndrs+ , ifPatExBndrs = ex_bndrs+ , ifPatProvCtxt = prov_ctxt+ , ifPatReqCtxt = req_ctxt+ , ifPatArgs = args+ , ifPatTy = pat_ty+ , ifFieldLabels = lbls })+ = unitNameSet matcher &&&+ maybe emptyNameSet (unitNameSet . fst) mb_builder &&&+ freeNamesIfTyVarBndrs univ_bndrs &&&+ freeNamesIfTyVarBndrs ex_bndrs &&&+ freeNamesIfContext prov_ctxt &&&+ freeNamesIfContext req_ctxt &&&+ fnList freeNamesIfType args &&&+ freeNamesIfType pat_ty &&&+ mkNameSet (map flSelector lbls)++freeNamesIfClassBody :: IfaceClassBody -> NameSet+freeNamesIfClassBody IfAbstractClass+ = emptyNameSet+freeNamesIfClassBody (IfConcreteClass{ ifClassCtxt = ctxt, ifATs = ats, ifSigs = sigs })+ = freeNamesIfContext ctxt &&&+ fnList freeNamesIfAT ats &&&+ fnList freeNamesIfClsSig sigs+ freeNamesIfAxBranch :: IfaceAxBranch -> NameSet freeNamesIfAxBranch (IfaceAxBranch { ifaxbTyVars = tyvars , ifaxbCoVars = covars@@ -1350,7 +1391,7 @@ , ifConFields = flds , ifConEqSpec = eq_spec , ifConStricts = bangs })- = freeNamesIfTyVarBndrs ex_tvs &&&+ = fnList freeNamesIfTvBndr ex_tvs &&& freeNamesIfContext ctxt &&& fnList freeNamesIfType arg_tys &&& mkNameSet (map flSelector flds) &&&@@ -1392,8 +1433,9 @@ = freeNamesIfCoercion c1 &&& freeNamesIfCoercion c2 freeNamesIfCoercion (IfaceForAllCo _ kind_co co) = freeNamesIfCoercion kind_co &&& freeNamesIfCoercion co-freeNamesIfCoercion (IfaceCoVarCo _)- = emptyNameSet+freeNamesIfCoercion (IfaceFreeCoVar _) = emptyNameSet+freeNamesIfCoercion (IfaceCoVarCo _) = emptyNameSet+freeNamesIfCoercion (IfaceHoleCo _) = emptyNameSet freeNamesIfCoercion (IfaceAxiomInstCo ax _ cos) = unitNameSet ax &&& fnList freeNamesIfCoercion cos freeNamesIfCoercion (IfaceUnivCo p _ t1 t2)@@ -1423,7 +1465,6 @@ freeNamesIfProv (IfacePhantomProv co) = freeNamesIfCoercion co freeNamesIfProv (IfaceProofIrrelProv co) = freeNamesIfCoercion co freeNamesIfProv (IfacePluginProv _) = emptyNameSet-freeNamesIfProv (IfaceHoleProv _) = emptyNameSet freeNamesIfTyVarBndr :: TyVarBndr IfaceTvBndr vis -> NameSet freeNamesIfTyVarBndr (TvBndr tv _) = freeNamesIfTvBndr tv@@ -1833,7 +1874,7 @@ _ -> error "Binary(IfaceConDecls).get: Invalid IfaceConDecls" instance Binary IfaceConDecl where- put_ bh (IfCon a1 a2 a3 a4 a5 a6 a7 a8 a9 a10) = do+ put_ bh (IfCon a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11) = do putIfaceTopBndr bh a1 put_ bh a2 put_ bh a3@@ -1841,10 +1882,11 @@ put_ bh a5 put_ bh a6 put_ bh a7- put_ bh (length a8)- mapM_ (put_ bh) a8- put_ bh a9+ put_ bh a8+ put_ bh (length a9)+ mapM_ (put_ bh) a9 put_ bh a10+ put_ bh a11 get bh = do a1 <- getIfaceTopBndr bh a2 <- get bh@@ -1853,11 +1895,12 @@ a5 <- get bh a6 <- get bh a7 <- get bh+ a8 <- get bh n_fields <- get bh- a8 <- replicateM n_fields (get bh)- a9 <- get bh+ a9 <- replicateM n_fields (get bh) a10 <- get bh- return (IfCon a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)+ a11 <- get bh+ return (IfCon a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11) instance Binary IfaceBang where put_ bh IfNoBang = putByte bh 0
iface/IfaceType.hs view
@@ -21,22 +21,22 @@ IfaceTvBndr, IfaceIdBndr, IfaceTyConBinder, IfaceForAllBndr, ArgFlag(..), ShowForAllFlag(..), + ifForAllBndrTyVar, ifForAllBndrName, ifTyConBinderTyVar, ifTyConBinderName, -- Equality testing- IfRnEnv2, emptyIfRnEnv2, eqIfaceType, eqIfaceTypes,- eqIfaceTcArgs, eqIfaceTvBndrs, isIfaceLiftedTypeKind,+ isIfaceLiftedTypeKind, -- Conversion from IfaceTcArgs -> [IfaceType] tcArgsIfaceTypes, -- Printing- pprIfaceType, pprParendIfaceType,+ pprIfaceType, pprParendIfaceType, pprPrecIfaceType, pprIfaceContext, pprIfaceContextArr, pprIfaceIdBndr, pprIfaceLamBndr, pprIfaceTvBndr, pprIfaceTyConBinders, pprIfaceBndrs, pprIfaceTcArgs, pprParendIfaceTcArgs,- pprIfaceForAllPart, pprIfaceForAll, pprIfaceSigmaType,- pprIfaceTyLit,+ pprIfaceForAllPart, pprIfaceForAllPartMust, pprIfaceForAll,+ pprIfaceSigmaType, pprIfaceTyLit, pprIfaceCoercion, pprParendIfaceCoercion, splitIfaceSigmaTy, pprIfaceTypeApp, pprUserIfaceForAll, pprIfaceCoTcApp, pprTyTcApp, pprIfacePrefixApp,@@ -44,12 +44,14 @@ suppressIfaceInvisibles, stripIfaceInvisVars, stripInvisArgs,- substIfaceType, substIfaceTyVar, substIfaceTcArgs, mkIfaceTySubst,- eqIfaceTvBndr++ mkIfaceTySubst, substIfaceTyVar, substIfaceTcArgs, inDomIfaceTySubst ) where #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} TysWiredIn ( liftedRepDataConTyCon ) import DynFlags@@ -63,10 +65,11 @@ import Outputable import FastString import FastStringEnv-import UniqFM import Util +import Data.Maybe( isJust ) import Data.List (foldl')+import qualified Data.Semigroup as Semi {- ************************************************************************@@ -110,7 +113,7 @@ type IfaceKind = IfaceType data IfaceType -- A kind of universal type, used for types and kinds- = IfaceFreeTyVar TyVar -- See Note [Free tyvars in IfaceType]+ = IfaceFreeTyVar TyVar -- See Note [Free tyvars in IfaceType] | IfaceTyVar IfLclName -- Type/coercion variable only, not tycon | IfaceLitTy IfaceTyLit | IfaceAppTy IfaceType IfaceType@@ -150,11 +153,14 @@ | ITC_Invis IfaceKind IfaceTcArgs -- "Invis" means don't show when pretty-printing -- except with -fprint-explicit-kinds +instance Semi.Semigroup IfaceTcArgs where+ ITC_Nil <> xs = xs+ ITC_Vis ty rest <> xs = ITC_Vis ty (rest Semi.<> xs)+ ITC_Invis ki rest <> xs = ITC_Invis ki (rest Semi.<> xs)+ instance Monoid IfaceTcArgs where mempty = ITC_Nil- ITC_Nil `mappend` xs = xs- ITC_Vis ty rest `mappend` xs = ITC_Vis ty (rest `mappend` xs)- ITC_Invis ki rest `mappend` xs = ITC_Invis ki (rest `mappend` xs)+ mappend = (Semi.<>) -- Encodes type constructors, kind constructors, -- coercion constructors, the lot.@@ -180,16 +186,18 @@ | IfaceSumTyCon !Arity -- ^ e.g. @(a | b | c)@ - | IfaceEqualityTyCon !Bool- -- ^ a type equality. 'True' indicates kind-homogeneous.- -- See Note [Equality predicates in IfaceType] for- -- details.+ | IfaceEqualityTyCon+ -- ^ A heterogeneous equality TyCon+ -- (i.e. eqPrimTyCon, eqReprPrimTyCon, heqTyCon)+ -- that is actually being applied to two types+ -- of the same kind. This affects pretty-printing+ -- only: see Note [Equality predicates in IfaceType] deriving (Eq) {- Note [Free tyvars in IfaceType] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Nowadays (since Nov 16, 2016) we pretty-print a Type by converting to an-IfaceType and pretty printing that. This eliminates a lot of+Nowadays (since Nov 16, 2016) we pretty-print a Type by converting to+an IfaceType and pretty printing that. This eliminates a lot of pretty-print duplication, and it matches what we do with pretty-printing TyThings. @@ -205,29 +213,34 @@ to deserialise one. IfaceFreeTyVar is used only in the "convert to IfaceType and then pretty-print" pipeline. +We do the same for covars, naturally. Note [Equality predicates in IfaceType] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GHC has several varieties of type equality (see Note [The equality types story]-in TysPrim for details) which all must be rendered with different surface syntax-during pretty-printing. Which syntax we use depends upon,-- 1. Which predicate tycon was used- 2. Whether the types being compared are of the same kind.+in TysPrim for details). In an effort to avoid confusing users, we suppress+the differences during "normal" pretty printing. Specifically we display them+like this: -Unfortunately, determining (2) from an IfaceType isn't possible since we can't-see through type synonyms. Consequently, we need to record whether the equality-is homogeneous or not in IfaceTyConSort for the purposes of pretty-printing.+ Predicate Pretty-printed as+ Homogeneous case Heterogeneous case+ ---------------- ----------------- -------------------+ (~) eqTyCon ~ N/A+ (~~) heqTyCon ~ ~~+ (~#) eqPrimTyCon ~# ~~+ (~R#) eqReprPrimTyCon Coercible Coercible -Namely we handle these cases,+By "homogeneeous case" we mean cases where a hetero-kinded equality+(all but the first above) is actually applied to two identical kinds.+Unfortunately, determining this from an IfaceType isn't possible since+we can't see through type synonyms. Consequently, we need to record+whether this particular application is homogeneous in IfaceTyConSort+for the purposes of pretty-printing. - Predicate Homogeneous Heterogeneous- ---------------- ----------- -------------- eqTyCon ~ N/A- heqTyCon ~ ~~- eqPrimTyCon ~# ~~- eqReprPrimTyCon Coercible Coercible+All this suppresses information. To get the ground truth, use -dppr-debug+(see 'print_eqs' in 'ppr_equality'). +See Note [The equality types story] in TysPrim. -} data IfaceTyConInfo -- Used to guide pretty-printing@@ -254,29 +267,26 @@ | IfaceKindCo IfaceCoercion | IfaceSubCo IfaceCoercion | IfaceAxiomRuleCo IfLclName [IfaceCoercion]+ | IfaceFreeCoVar CoVar -- See Note [Free tyvars in IfaceType]+ | IfaceHoleCo CoVar -- ^ See Note [Holes in IfaceCoercion] data IfaceUnivCoProv = IfaceUnsafeCoerceProv | IfacePhantomProv IfaceCoercion | IfaceProofIrrelProv IfaceCoercion | IfacePluginProv String- | IfaceHoleProv Unique- -- ^ See Note [Holes in IfaceUnivCoProv] -{--Note [Holes in IfaceUnivCoProv]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When typechecking fails the typechecker will produce a HoleProv UnivCoProv to-stand in place of the unproven assertion. While we generally don't want to let-these unproven assertions leak into interface files, we still need to be able to-pretty-print them as we use IfaceType's pretty-printer to render Types. For this-reason IfaceUnivCoProv has a IfaceHoleProv constructor; however, we fails when-asked to serialize to a IfaceHoleProv to ensure that they don't end up in an-interface file. To avoid an import loop between IfaceType and TyCoRep we only-keep the hole's Unique, since that is all we need to print.--}+{- Note [Holes in IfaceCoercion]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When typechecking fails the typechecker will produce a HoleCo to stand+in place of the unproven assertion. While we generally don't want to+let these unproven assertions leak into interface files, we still need+to be able to pretty-print them as we use IfaceType's pretty-printer+to render Types. For this reason IfaceCoercion has a IfaceHoleCo+constructor; however, we fails when asked to serialize to a+IfaceHoleCo to ensure that they don't end up in an interface file. -{-+ %************************************************************************ %* * Functions over IFaceTypes@@ -287,9 +297,6 @@ ifaceTyConHasKey :: IfaceTyCon -> Unique -> Bool ifaceTyConHasKey tc key = ifaceTyConName tc `hasKey` key -eqIfaceTvBndr :: IfaceTvBndr -> IfaceTvBndr -> Bool-eqIfaceTvBndr (occ1, _) (occ2, _) = occ1 == occ2- isIfaceLiftedTypeKind :: IfaceKind -> Bool isIfaceLiftedTypeKind (IfaceTyConApp tc ITC_Nil) = isLiftedTypeKindTyConName (ifaceTyConName tc)@@ -322,20 +329,28 @@ where suppress _ [] = [] suppress [] a = a- suppress (k:ks) a@(_:xs)- | isInvisibleTyConBinder k = suppress ks xs- | otherwise = a+ suppress (k:ks) (x:xs)+ | isInvisibleTyConBinder k = suppress ks xs+ | otherwise = x : suppress ks xs stripIfaceInvisVars :: DynFlags -> [IfaceTyConBinder] -> [IfaceTyConBinder] stripIfaceInvisVars dflags tyvars | gopt Opt_PrintExplicitKinds dflags = tyvars | otherwise = filterOut isInvisibleTyConBinder tyvars --- | Extract a IfaceTvBndr from a IfaceTyConBinder+-- | Extract an 'IfaceTvBndr' from an 'IfaceForAllBndr'.+ifForAllBndrTyVar :: IfaceForAllBndr -> IfaceTvBndr+ifForAllBndrTyVar = binderVar++-- | Extract the variable name from an 'IfaceForAllBndr'.+ifForAllBndrName :: IfaceForAllBndr -> IfLclName+ifForAllBndrName fab = ifaceTvBndrName (ifForAllBndrTyVar fab)++-- | Extract an 'IfaceTvBndr' from an 'IfaceTyConBinder'. ifTyConBinderTyVar :: IfaceTyConBinder -> IfaceTvBndr ifTyConBinderTyVar = binderVar --- | Extract the variable name from a IfaceTyConBinder+-- | Extract the variable name from an 'IfaceTyConBinder'. ifTyConBinderName :: IfaceTyConBinder -> IfLclName ifTyConBinderName tcb = ifaceTvBndrName (ifTyConBinderTyVar tcb) @@ -360,18 +375,24 @@ go_args (ITC_Vis arg args) = go arg && go_args args go_args (ITC_Invis arg args) = go arg && go_args args -{--Substitutions on IfaceType. This is only used during pretty-printing to construct-the result type of a GADT, and does not deal with binders (eg IfaceForAll), so-it doesn't need fancy capture stuff.--}+{- Note [Substitution on IfaceType]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Substitutions on IfaceType are done only during pretty-printing to+construct the result type of a GADT, and does not deal with binders+(eg IfaceForAll), so it doesn't need fancy capture stuff. -} -type IfaceTySubst = FastStringEnv IfaceType+type IfaceTySubst = FastStringEnv IfaceType -- Note [Substitution on IfaceType] -mkIfaceTySubst :: [IfaceTvBndr] -> [IfaceType] -> IfaceTySubst-mkIfaceTySubst tvs tys = mkFsEnv $ zipWithEqual "mkIfaceTySubst" (\(fs,_) ty -> (fs,ty)) tvs tys+mkIfaceTySubst :: [(IfLclName,IfaceType)] -> IfaceTySubst+-- See Note [Substitution on IfaceType]+mkIfaceTySubst eq_spec = mkFsEnv eq_spec +inDomIfaceTySubst :: IfaceTySubst -> IfaceTvBndr -> Bool+-- See Note [Substitution on IfaceType]+inDomIfaceTySubst subst (fs, _) = isJust (lookupFsEnv subst fs)+ substIfaceType :: IfaceTySubst -> IfaceType -> IfaceType+-- See Note [Substitution on IfaceType] substIfaceType env ty = go ty where@@ -392,7 +413,9 @@ go_co (IfaceTyConAppCo r tc cos) = IfaceTyConAppCo r tc (go_cos cos) go_co (IfaceAppCo c1 c2) = IfaceAppCo (go_co c1) (go_co c2) go_co (IfaceForAllCo {}) = pprPanic "substIfaceCoercion" (ppr ty)+ go_co (IfaceFreeCoVar cv) = IfaceFreeCoVar cv go_co (IfaceCoVarCo cv) = IfaceCoVarCo cv+ go_co (IfaceHoleCo cv) = IfaceHoleCo cv go_co (IfaceAxiomInstCo a i cos) = IfaceAxiomInstCo a i (go_cos cos) go_co (IfaceUnivCo prov r t1 t2) = IfaceUnivCo (go_prov prov) r (go t1) (go t2) go_co (IfaceSymCo co) = IfaceSymCo (go_co co)@@ -411,7 +434,6 @@ go_prov (IfacePhantomProv co) = IfacePhantomProv (go_co co) go_prov (IfaceProofIrrelProv co) = IfaceProofIrrelProv (go_co co) go_prov (IfacePluginProv str) = IfacePluginProv str- go_prov (IfaceHoleProv h) = IfaceHoleProv h substIfaceTcArgs :: IfaceTySubst -> IfaceTcArgs -> IfaceTcArgs substIfaceTcArgs env args@@ -426,107 +448,7 @@ | Just ty <- lookupFsEnv env tv = ty | otherwise = IfaceTyVar tv -{--************************************************************************-* *- Equality over IfaceTypes-* *-************************************************************************ -Note [No kind check in ifaces]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We check iface types for equality only when checking the consistency-between two user-written signatures. In these cases, there is no possibility-for a kind mismatch. So we omit the kind check (which would be impossible to-write, anyway.)---}---- Like an RnEnv2, but mapping from FastString to deBruijn index--- DeBruijn; see eqTypeX-type BoundVar = Int-data IfRnEnv2- = IRV2 { ifenvL :: UniqFM BoundVar -- from FastString- , ifenvR :: UniqFM BoundVar- , ifenv_next :: BoundVar- }--emptyIfRnEnv2 :: IfRnEnv2-emptyIfRnEnv2 = IRV2 { ifenvL = emptyUFM- , ifenvR = emptyUFM- , ifenv_next = 0 }--rnIfOccL :: IfRnEnv2 -> IfLclName -> Maybe BoundVar-rnIfOccL env = lookupUFM (ifenvL env)--rnIfOccR :: IfRnEnv2 -> IfLclName -> Maybe BoundVar-rnIfOccR env = lookupUFM (ifenvR env)--extendIfRnEnv2 :: IfRnEnv2 -> IfLclName -> IfLclName -> IfRnEnv2-extendIfRnEnv2 IRV2 { ifenvL = lenv- , ifenvR = renv- , ifenv_next = n } tv1 tv2- = IRV2 { ifenvL = addToUFM lenv tv1 n- , ifenvR = addToUFM renv tv2 n- , ifenv_next = n + 1- }---- See Note [No kind check in ifaces]-eqIfaceType :: IfRnEnv2 -> IfaceType -> IfaceType -> Bool-eqIfaceType _ (IfaceFreeTyVar tv1) (IfaceFreeTyVar tv2)- = tv1 == tv2 -- Should not happen-eqIfaceType env (IfaceTyVar tv1) (IfaceTyVar tv2) =- case (rnIfOccL env tv1, rnIfOccR env tv2) of- (Just v1, Just v2) -> v1 == v2- (Nothing, Nothing) -> tv1 == tv2- _ -> False-eqIfaceType _ (IfaceLitTy l1) (IfaceLitTy l2) = l1 == l2-eqIfaceType env (IfaceAppTy t11 t12) (IfaceAppTy t21 t22)- = eqIfaceType env t11 t21 && eqIfaceType env t12 t22-eqIfaceType env (IfaceFunTy t11 t12) (IfaceFunTy t21 t22)- = eqIfaceType env t11 t21 && eqIfaceType env t12 t22-eqIfaceType env (IfaceDFunTy t11 t12) (IfaceDFunTy t21 t22)- = eqIfaceType env t11 t21 && eqIfaceType env t12 t22-eqIfaceType env (IfaceForAllTy bndr1 t1) (IfaceForAllTy bndr2 t2)- = eqIfaceForAllBndr env bndr1 bndr2 (\env' -> eqIfaceType env' t1 t2)-eqIfaceType env (IfaceTyConApp tc1 tys1) (IfaceTyConApp tc2 tys2)- = tc1 == tc2 && eqIfaceTcArgs env tys1 tys2-eqIfaceType env (IfaceTupleTy s1 tc1 tys1) (IfaceTupleTy s2 tc2 tys2)- = s1 == s2 && tc1 == tc2 && eqIfaceTcArgs env tys1 tys2-eqIfaceType env (IfaceCastTy t1 _) (IfaceCastTy t2 _)- = eqIfaceType env t1 t2-eqIfaceType _ (IfaceCoercionTy {}) (IfaceCoercionTy {})- = True-eqIfaceType _ _ _ = False--eqIfaceTypes :: IfRnEnv2 -> [IfaceType] -> [IfaceType] -> Bool-eqIfaceTypes env tys1 tys2 = and (zipWith (eqIfaceType env) tys1 tys2)--eqIfaceForAllBndr :: IfRnEnv2 -> IfaceForAllBndr -> IfaceForAllBndr- -> (IfRnEnv2 -> Bool) -- continuation- -> Bool-eqIfaceForAllBndr env (TvBndr (tv1, k1) vis1) (TvBndr (tv2, k2) vis2) k- = eqIfaceType env k1 k2 && vis1 == vis2 &&- k (extendIfRnEnv2 env tv1 tv2)--eqIfaceTcArgs :: IfRnEnv2 -> IfaceTcArgs -> IfaceTcArgs -> Bool-eqIfaceTcArgs _ ITC_Nil ITC_Nil = True-eqIfaceTcArgs env (ITC_Vis ty1 tys1) (ITC_Vis ty2 tys2)- = eqIfaceType env ty1 ty2 && eqIfaceTcArgs env tys1 tys2-eqIfaceTcArgs env (ITC_Invis ty1 tys1) (ITC_Invis ty2 tys2)- = eqIfaceType env ty1 ty2 && eqIfaceTcArgs env tys1 tys2-eqIfaceTcArgs _ _ _ = False---- | Similar to 'eqTyVarBndrs', checks that tyvar lists--- are the same length and have matching kinds; if so, extend the--- 'IfRnEnv2'. Returns 'Nothing' if they don't match.-eqIfaceTvBndrs :: IfRnEnv2 -> [IfaceTvBndr] -> [IfaceTvBndr] -> Maybe IfRnEnv2-eqIfaceTvBndrs env [] [] = Just env-eqIfaceTvBndrs env ((tv1, k1):tvs1) ((tv2, k2):tvs2)- | eqIfaceType env k1 k2- = eqIfaceTvBndrs (extendIfRnEnv2 env tv1 tv2) tvs1 tvs2-eqIfaceTvBndrs _ _ _ = Nothing- {- ************************************************************************ * *@@ -590,15 +512,15 @@ then yes else no -pprIfaceInfixApp :: (TyPrec -> a -> SDoc) -> TyPrec -> SDoc -> a -> a -> SDoc-pprIfaceInfixApp pp p pp_tc ty1 ty2- = maybeParen p FunPrec $- sep [pp FunPrec ty1, pprInfixVar True pp_tc <+> pp FunPrec ty2]+pprIfaceInfixApp :: TyPrec -> SDoc -> SDoc -> SDoc -> SDoc+pprIfaceInfixApp ctxt_prec pp_tc pp_ty1 pp_ty2+ = maybeParen ctxt_prec TyOpPrec $+ sep [pp_ty1, pp_tc <+> pp_ty2] pprIfacePrefixApp :: TyPrec -> SDoc -> [SDoc] -> SDoc-pprIfacePrefixApp p pp_fun pp_tys+pprIfacePrefixApp ctxt_prec pp_fun pp_tys | null pp_tys = pp_fun- | otherwise = maybeParen p TyConPrec $+ | otherwise = maybeParen ctxt_prec TyConPrec $ hang pp_fun 2 (sep pp_tys) -- ----------------------------- Printing binders ------------------------------------@@ -663,9 +585,12 @@ ppr ty = pprIfaceType ty pprIfaceType, pprParendIfaceType :: IfaceType -> SDoc-pprIfaceType = eliminateRuntimeRep (ppr_ty TopPrec)-pprParendIfaceType = eliminateRuntimeRep (ppr_ty TyConPrec)+pprIfaceType = pprPrecIfaceType TopPrec+pprParendIfaceType = pprPrecIfaceType TyConPrec +pprPrecIfaceType :: TyPrec -> IfaceType -> SDoc+pprPrecIfaceType prec ty = eliminateRuntimeRep (ppr_ty prec) ty+ ppr_ty :: TyPrec -> IfaceType -> SDoc ppr_ty _ (IfaceFreeTyVar tyvar) = ppr tyvar -- This is the main reson for IfaceFreeTyVar! ppr_ty _ (IfaceTyVar tyvar) = ppr tyvar -- See Note [TcTyVars in IfaceType]@@ -768,11 +693,13 @@ go :: FastStringEnv () -> IfaceType -> IfaceType go subs (IfaceForAllTy bndr ty) | isRuntimeRep var_kind+ , isInvisibleArgFlag (binderArgFlag bndr) -- don't default *visible* quantification+ -- or we get the mess in #13963 = let subs' = extendFsEnv subs var () in go subs' ty | otherwise = IfaceForAllTy (TvBndr (var, go subs var_kind) (binderArgFlag bndr))- (go subs ty)+ (go subs ty) where var :: IfLclName (var, var_kind) = binderVar bndr@@ -831,6 +758,11 @@ pprIfaceForAllPart tvs ctxt sdoc = ppr_iface_forall_part ShowForAllWhen tvs ctxt sdoc +-- | Like 'pprIfaceForAllPart', but always uses an explicit @forall@.+pprIfaceForAllPartMust :: [IfaceForAllBndr] -> [IfacePredType] -> SDoc -> SDoc+pprIfaceForAllPartMust tvs ctxt sdoc+ = ppr_iface_forall_part ShowForAllMust tvs ctxt sdoc+ pprIfaceForAllCoPart :: [(IfLclName, IfaceCoercion)] -> SDoc -> SDoc pprIfaceForAllCoPart tvs sdoc = sep [ pprIfaceForAllCo tvs, sdoc ]@@ -973,13 +905,13 @@ = kindStar | otherwise- = sdocWithPprDebug $ \dbg ->+ = getPprDebug $ \dbg -> if | not dbg && tc `ifaceTyConHasKey` errorMessageTypeErrorFamKey -- Suppress detail unles you _really_ want to see -> text "(TypeError ...)" - | Just doc <- ppr_equality tc (tcArgsIfaceTypes tys)- -> maybeParen ctxt_prec TyConPrec doc+ | Just doc <- ppr_equality ctxt_prec tc (tcArgsIfaceTypes tys)+ -> doc | otherwise -> ppr_iface_tc_app ppr_ty ctxt_prec tc tys_wo_kinds@@ -988,10 +920,16 @@ tys_wo_kinds = tcArgsIfaceTypes $ stripInvisArgs dflags tys -- | Pretty-print a type-level equality.+-- Returns (Just doc) if the argument is a /saturated/ application+-- of eqTyCon (~)+-- eqPrimTyCon (~#)+-- eqReprPrimTyCon (~R#)+-- hEqTyCon (~~) ----- See Note [Equality predicates in IfaceType].-ppr_equality :: IfaceTyCon -> [IfaceType] -> Maybe SDoc-ppr_equality tc args+-- See Note [Equality predicates in IfaceType]+-- and Note [The equality types story] in TysPrim+ppr_equality :: TyPrec -> IfaceTyCon -> [IfaceType] -> Maybe SDoc+ppr_equality ctxt_prec tc args | hetero_eq_tc , [k1, k2, t1, t2] <- args = Just $ print_equality (k1, k2, t1, t2)@@ -1004,22 +942,24 @@ = Nothing where homogeneous = case ifaceTyConSort $ ifaceTyConInfo tc of- IfaceEqualityTyCon hom -> hom- _other -> pprPanic "ppr_equality: homogeneity" (ppr tc)+ IfaceEqualityTyCon -> True+ _other -> False+ -- True <=> a heterogeneous equality whose arguments+ -- are (in this case) of the same kind+ tc_name = ifaceTyConName tc pp = ppr_ty hom_eq_tc = tc_name `hasKey` eqTyConKey -- (~) hetero_eq_tc = tc_name `hasKey` eqPrimTyConKey -- (~#) || tc_name `hasKey` eqReprPrimTyConKey -- (~R#) || tc_name `hasKey` heqTyConKey -- (~~)- print_equality args =- sdocWithDynFlags- $ \dflags -> getPprStyle- $ \style -> print_equality' args style dflags+ sdocWithDynFlags $ \dflags ->+ getPprStyle $ \style ->+ print_equality' args style dflags print_equality' (ki1, ki2, ty1, ty2) style dflags- | print_eqs+ | print_eqs -- No magic, just print the original TyCon = ppr_infix_eq (ppr tc) | hetero_eq_tc@@ -1028,14 +968,15 @@ | otherwise = if tc_name `hasKey` eqReprPrimTyConKey- then text "Coercible"- <+> sep [ pp TyConPrec ty1, pp TyConPrec ty2 ]- else sep [pp TyOpPrec ty1, char '~', pp TyOpPrec ty2]+ then pprIfacePrefixApp ctxt_prec (text "Coercible")+ [pp TyConPrec ty1, pp TyConPrec ty2]+ else pprIfaceInfixApp ctxt_prec (char '~')+ (pp TyOpPrec ty1) (pp TyOpPrec ty2) where ppr_infix_eq eq_op- = sep [ parens (pp TyOpPrec ty1 <+> dcolon <+> pp TyOpPrec ki1)- , eq_op- , parens (pp TyOpPrec ty2 <+> dcolon <+> pp TyOpPrec ki2) ]+ = pprIfaceInfixApp ctxt_prec eq_op+ (parens (pp TopPrec ty1 <+> dcolon <+> pp TyOpPrec ki1))+ (parens (pp TopPrec ty2 <+> dcolon <+> pp TyOpPrec ki2)) print_kinds = gopt Opt_PrintExplicitKinds dflags print_eqs = gopt Opt_PrintEqualityRelations dflags ||@@ -1061,7 +1002,8 @@ | [ty1,ty2] <- tys -- Infix, two arguments; -- we know nothing of precedence though- = pprIfaceInfixApp pp ctxt_prec (ppr tc) ty1 ty2+ = pprIfaceInfixApp ctxt_prec (ppr tc)+ (pp TyOpPrec ty1) (pp TyOpPrec ty2) | otherwise = pprIfacePrefixApp ctxt_prec (parens (ppr tc)) (map (pp TyConPrec) tys)@@ -1122,7 +1064,8 @@ = maybeParen ctxt_prec TyConPrec $ ppr_co FunPrec co1 <+> pprParendIfaceCoercion co2 ppr_co ctxt_prec co@(IfaceForAllCo {})- = maybeParen ctxt_prec FunPrec (pprIfaceForAllCoPart tvs (pprIfaceCoercion inner_co))+ = maybeParen ctxt_prec FunPrec $+ pprIfaceForAllCoPart tvs (pprIfaceCoercion inner_co) where (tvs, inner_co) = split_co co @@ -1130,17 +1073,17 @@ = let (tvs, co'') = split_co co' in ((name,kind_co):tvs,co'') split_co co' = ([], co') -ppr_co _ (IfaceCoVarCo covar) = ppr covar+-- Why these three? See Note [TcTyVars in IfaceType]+ppr_co _ (IfaceFreeCoVar covar) = ppr covar+ppr_co _ (IfaceCoVarCo covar) = ppr covar+ppr_co _ (IfaceHoleCo covar) = braces (ppr covar) ppr_co ctxt_prec (IfaceUnivCo IfaceUnsafeCoerceProv r ty1 ty2) = maybeParen ctxt_prec TyConPrec $ text "UnsafeCo" <+> ppr r <+> pprParendIfaceType ty1 <+> pprParendIfaceType ty2 -ppr_co _ctxt_prec (IfaceUnivCo (IfaceHoleProv u) _ _ _)- = braces $ ppr u--ppr_co _ (IfaceUnivCo _ _ ty1 ty2)+ppr_co _ (IfaceUnivCo _ _ ty1 ty2) = angleBrackets ( ppr ty1 <> comma <+> ppr ty2 ) ppr_co ctxt_prec (IfaceInstCo co ty)@@ -1156,7 +1099,8 @@ ppr_co ctxt_prec (IfaceSymCo co) = ppr_special_co ctxt_prec (text "Sym") [co] ppr_co ctxt_prec (IfaceTransCo co1 co2)- = ppr_special_co ctxt_prec (text "Trans") [co1,co2]+ = maybeParen ctxt_prec TyOpPrec $+ ppr_co TyOpPrec co1 <+> semi <+> ppr_co TyOpPrec co2 ppr_co ctxt_prec (IfaceNthCo d co) = ppr_special_co ctxt_prec (text "Nth:" <> int d) [co] ppr_co ctxt_prec (IfaceLRCo lr co)@@ -1217,9 +1161,7 @@ put_ bh IfaceNormalTyCon = putByte bh 0 put_ bh (IfaceTupleTyCon arity sort) = putByte bh 1 >> put_ bh arity >> put_ bh sort put_ bh (IfaceSumTyCon arity) = putByte bh 2 >> put_ bh arity- put_ bh (IfaceEqualityTyCon hom)- | hom = putByte bh 3- | otherwise = putByte bh 4+ put_ bh IfaceEqualityTyCon = putByte bh 3 get bh = do n <- getByte bh@@ -1227,9 +1169,7 @@ 0 -> return IfaceNormalTyCon 1 -> IfaceTupleTyCon <$> get bh <*> get bh 2 -> IfaceSumTyCon <$> get bh- 3 -> return $ IfaceEqualityTyCon True- 4 -> return $ IfaceEqualityTyCon False- _ -> fail "Binary(IfaceTyConSort): fail"+ _ -> return IfaceEqualityTyCon instance Binary IfaceTyConInfo where put_ bh (IfaceTyConInfo i s) = put_ bh i >> put_ bh s@@ -1306,21 +1246,25 @@ --- | Prints "(C a, D b) =>", including the arrow. This is used when we want to--- print a context in a type.+-- | Prints "(C a, D b) =>", including the arrow.+-- Used when we want to print a context in a type, so we+-- use FunPrec to decide whether to parenthesise a singleton+-- predicate; e.g. Num a => a -> a pprIfaceContextArr :: [IfacePredType] -> SDoc pprIfaceContextArr [] = empty-pprIfaceContextArr [pred] = ppr_ty TyOpPrec pred <+> darrow-pprIfaceContextArr preds =- parens (fsep (punctuate comma (map ppr preds))) <+> darrow+pprIfaceContextArr [pred] = ppr_ty FunPrec pred <+> darrow+pprIfaceContextArr preds = ppr_parend_preds preds <+> darrow --- | Prints a context or @()@ if empty. This is used when, e.g., we want to--- display a context in an error message.-pprIfaceContext :: [IfacePredType] -> SDoc-pprIfaceContext [] = parens empty-pprIfaceContext [pred] = ppr_ty TyOpPrec pred-pprIfaceContext preds = parens (fsep (punctuate comma (map ppr preds)))+-- | Prints a context or @()@ if empty+-- You give it the context precedence+pprIfaceContext :: TyPrec -> [IfacePredType] -> SDoc+pprIfaceContext _ [] = text "()"+pprIfaceContext prec [pred] = ppr_ty prec pred+pprIfaceContext _ preds = ppr_parend_preds preds +ppr_parend_preds :: [IfacePredType] -> SDoc+ppr_parend_preds preds = parens (fsep (punctuate comma (map ppr preds)))+ instance Binary IfaceType where put_ _ (IfaceFreeTyVar tv) = pprPanic "Can't serialise IfaceFreeTyVar" (ppr tv)@@ -1455,6 +1399,11 @@ putByte bh 17 put_ bh a put_ bh b+ put_ _ (IfaceFreeCoVar cv)+ = pprPanic "Can't serialise IfaceFreeCoVar" (ppr cv)+ put_ _ (IfaceHoleCo cv)+ = pprPanic "Can't serialise IfaceHoleCo" (ppr cv)+ -- See Note [Holes in IfaceUnivCoProv] get bh = do tag <- getByte bh@@ -1525,9 +1474,6 @@ put_ bh (IfacePluginProv a) = do putByte bh 4 put_ bh a- put_ _ (IfaceHoleProv _) =- pprPanic "Binary(IfaceUnivCoProv) hit a hole" empty- -- See Note [Holes in IfaceUnivCoProv] get bh = do tag <- getByte bh
iface/IfaceType.hs-boot view
@@ -1,37 +1,18 @@--- Exists to allow TyCoRep to import pretty-printers-module IfaceType where+-- Used only by ToIface.hs-boot +module IfaceType( IfaceType, IfaceTyCon, IfaceForAllBndr+ , IfaceCoercion, IfaceTyLit, IfaceTcArgs ) where+ import Var (TyVarBndr, ArgFlag)-import TyCon (TyConBndrVis)-import BasicTypes (TyPrec)-import Outputable (Outputable, SDoc) import FastString (FastString) +data IfaceTcArgs type IfLclName = FastString type IfaceKind = IfaceType-type IfacePredType = IfaceType -data ShowForAllFlag data IfaceType data IfaceTyCon data IfaceTyLit data IfaceCoercion-data IfaceTcArgs-type IfaceTvBndr = (IfLclName, IfaceKind)-type IfaceTyConBinder = TyVarBndr IfaceTvBndr TyConBndrVis+type IfaceTvBndr = (IfLclName, IfaceKind) type IfaceForAllBndr = TyVarBndr IfaceTvBndr ArgFlag--instance Outputable IfaceType--pprIfaceType, pprParendIfaceType :: IfaceType -> SDoc-pprIfaceSigmaType :: ShowForAllFlag -> IfaceType -> SDoc-pprIfaceTyLit :: IfaceTyLit -> SDoc-pprIfaceForAll :: [IfaceForAllBndr] -> SDoc-pprIfaceTvBndr :: Bool -> IfaceTvBndr -> SDoc-pprUserIfaceForAll :: [IfaceForAllBndr] -> SDoc-pprIfaceContext :: [IfacePredType] -> SDoc-pprIfaceContextArr :: [IfacePredType] -> SDoc-pprIfaceTypeApp :: TyPrec -> IfaceTyCon -> IfaceTcArgs -> SDoc-pprIfaceCoTcApp :: TyPrec -> IfaceTyCon -> [IfaceCoercion] -> SDoc-pprTyTcApp :: TyPrec -> IfaceTyCon -> IfaceTcArgs -> SDoc-pprIfacePrefixApp :: TyPrec -> SDoc -> [SDoc] -> SDoc
iface/LoadIface.hs view
@@ -32,6 +32,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} TcIface( tcIfaceDecl, tcIfaceRules, tcIfaceInst, tcIfaceFamInst, tcIfaceVectInfo, tcIfaceAnnotations, tcIfaceCompleteSigs )@@ -144,7 +146,7 @@ { eps <- getEps ; case lookupTypeEnv (eps_PTE eps) name of Just thing -> return $ Succeeded thing- Nothing -> let doc = ifPprDebug (found_things_msg eps $$ empty)+ Nothing -> let doc = whenPprDebug (found_things_msg eps $$ empty) $$ not_found_msg in return $ Failed doc }}}@@ -1018,6 +1020,8 @@ , nest 2 (text "export-list hash:" <+> ppr (mi_exp_hash iface)) , nest 2 (text "orphan hash:" <+> ppr (mi_orphan_hash iface)) , nest 2 (text "flag hash:" <+> ppr (mi_flag_hash iface))+ , nest 2 (text "opt_hash:" <+> ppr (mi_opt_hash iface))+ , nest 2 (text "hpc_hash:" <+> ppr (mi_hpc_hash iface)) , nest 2 (text "sig of:" <+> ppr (mi_sig_of iface)) , nest 2 (text "used TH splices:" <+> ppr (mi_used_th iface)) , nest 2 (text "where")@@ -1071,7 +1075,8 @@ ) pprUsage usage@UsageFile{} = hsep [text "addDependentFile",- doubleQuotes (text (usg_file_path usage))]+ doubleQuotes (text (usg_file_path usage)),+ ppr (usg_file_hash usage)] pprUsage usage@UsageMergedRequirement{} = hsep [text "merged", ppr (usg_mod usage), ppr (usg_mod_hash usage)]
iface/MkIface.hs view
@@ -4,6 +4,7 @@ -} {-# LANGUAGE CPP, NondecreasingIndentation #-}+{-# LANGUAGE MultiWayIf #-} -- | Module for constructing @ModIface@ values (interface files), -- writing them to disk and comparing two versions to see if@@ -58,6 +59,8 @@ #include "HsVersions.h" +import GhcPrelude+ import IfaceSyn import BinFingerprint import LoadIface@@ -277,6 +280,8 @@ mi_iface_hash = fingerprint0, mi_mod_hash = fingerprint0, mi_flag_hash = fingerprint0,+ mi_opt_hash = fingerprint0,+ mi_hpc_hash = fingerprint0, mi_exp_hash = fingerprint0, mi_used_th = used_th, mi_orphan_hash = fingerprint0,@@ -444,8 +449,8 @@ where extras = declExtras fix_fn ann_fn non_orph_rules non_orph_insts non_orph_fis decl - edges :: [(IfaceDeclABI, Unique, [Unique])]- edges = [ (abi, getUnique (getOccName decl), out)+ edges :: [ Node Unique IfaceDeclABI ]+ edges = [ DigraphNode abi (getUnique (getOccName decl)) out | decl <- new_decls , let abi = declABI decl , let out = localOccs $ freeNamesDeclABI abi@@ -476,10 +481,9 @@ extendOccEnvList env [ (b,n) | b <- ifaceDeclImplicitBndrs d ] where n = getOccName d - -- strongly-connected groups of declarations, in dependency order+ -- Strongly-connected groups of declarations, in dependency order groups :: [SCC IfaceDeclABI]- groups =- stronglyConnCompFromEdgedVerticesUniq edges+ groups = stronglyConnCompFromEdgedVerticesUniq edges global_hash_fn = mkHashFun hsc_env eps @@ -659,6 +663,10 @@ -- the abi hash and one that should flag_hash <- fingerprintDynFlags dflags this_mod putNameLiterally + opt_hash <- fingerprintOptFlags dflags putNameLiterally++ hpc_hash <- fingerprintHpcFlags dflags putNameLiterally+ -- the ABI hash depends on: -- - decls -- - export list@@ -694,6 +702,8 @@ mi_exp_hash = export_hash, mi_orphan_hash = orphan_hash, mi_flag_hash = flag_hash,+ mi_opt_hash = opt_hash,+ mi_hpc_hash = hpc_hash, mi_orphan = not ( all ifRuleAuto orph_rules -- See Note [Orphans and auto-generated rules] && null orph_insts@@ -967,9 +977,9 @@ else return fp oldMD5 dflags bh = do- tmp <- newTempName dflags "bin"+ tmp <- newTempName dflags CurrentModule "bin" writeBinMem bh tmp- tmp2 <- newTempName dflags "md5"+ tmp2 <- newTempName dflags CurrentModule "md5" let cmd = "md5sum " ++ tmp ++ " >" ++ tmp2 r <- system cmd case r of@@ -1199,6 +1209,10 @@ then return (RecompBecause "-this-unit-id changed", Nothing) else do { ; recomp <- checkFlagHash hsc_env iface ; if recompileRequired recomp then return (recomp, Nothing) else do {+ ; recomp <- checkOptimHash hsc_env iface+ ; if recompileRequired recomp then return (recomp, Nothing) else do {+ ; recomp <- checkHpcHash hsc_env iface+ ; if recompileRequired recomp then return (recomp, Nothing) else do { ; recomp <- checkMergedSignatures mod_summary iface ; if recompileRequired recomp then return (recomp, Nothing) else do { ; recomp <- checkHsig mod_summary iface@@ -1222,7 +1236,7 @@ ; updateEps_ $ \eps -> eps { eps_is_boot = mod_deps } ; recomp <- checkList [checkModUsage this_pkg u | u <- mi_usages iface] ; return (recomp, Just iface)- }}}}}}+ }}}}}}}} where this_pkg = thisPackage (hsc_dflags hsc_env) -- This is a bit of a hack really@@ -1254,6 +1268,36 @@ (text " Module flags have changed") old_hash new_hash +-- | Check the optimisation flags haven't changed+checkOptimHash :: HscEnv -> ModIface -> IfG RecompileRequired+checkOptimHash hsc_env iface = do+ let old_hash = mi_opt_hash iface+ new_hash <- liftIO $ fingerprintOptFlags (hsc_dflags hsc_env)+ putNameLiterally+ if | old_hash == new_hash+ -> up_to_date (text "Optimisation flags unchanged")+ | gopt Opt_IgnoreOptimChanges (hsc_dflags hsc_env)+ -> up_to_date (text "Optimisation flags changed; ignoring")+ | otherwise+ -> out_of_date_hash "Optimisation flags changed"+ (text " Optimisation flags have changed")+ old_hash new_hash++-- | Check the HPC flags haven't changed+checkHpcHash :: HscEnv -> ModIface -> IfG RecompileRequired+checkHpcHash hsc_env iface = do+ let old_hash = mi_hpc_hash iface+ new_hash <- liftIO $ fingerprintHpcFlags (hsc_dflags hsc_env)+ putNameLiterally+ if | old_hash == new_hash+ -> up_to_date (text "HPC flags unchanged")+ | gopt Opt_IgnoreHpcChanges (hsc_dflags hsc_env)+ -> up_to_date (text "HPC flags changed; ignoring")+ | otherwise+ -> out_of_date_hash "HPC flags changed"+ (text " HPC flags have changed")+ old_hash new_hash+ -- Check that the set of signatures we are merging in match. -- If the -unit-id flags change, this can change too. checkMergedSignatures :: ModSummary -> ModIface -> IfG RecompileRequired@@ -1399,7 +1443,7 @@ where recomp = RecompBecause (file ++ " changed") handle =-#ifdef DEBUG+#if defined(DEBUG) \e -> pprTrace "UsageFile" (text (show e)) $ return recomp #else \_ -> return recomp -- if we can't find the file, just recompile, don't fail@@ -1566,7 +1610,7 @@ ifFamFlav = to_if_fam_flav fam_flav, ifBinders = if_binders, ifResKind = if_res_kind,- ifFamInj = familyTyConInjectivityInfo tycon+ ifFamInj = tyConInjectivityInfo tycon }) | isAlgTyCon tycon@@ -1642,7 +1686,8 @@ = IfCon { ifConName = dataConName data_con, ifConInfix = dataConIsInfix data_con, ifConWrapper = isJust (dataConWrapId_maybe data_con),- ifConExTvs = map toIfaceForAllBndr ex_bndrs',+ ifConExTvs = map toIfaceTvBndr ex_tvs',+ ifConUserTvBinders = map toIfaceForAllBndr user_bndrs', ifConEqSpec = map (to_eq_spec . eqSpecPair) eq_spec, ifConCtxt = tidyToIfaceContext con_env2 theta, ifConArgTys = map (tidyToIfaceType con_env2) arg_tys,@@ -1652,9 +1697,9 @@ ifConSrcStricts = map toIfaceSrcBang (dataConSrcBangs data_con)} where- (univ_tvs, _ex_tvs, eq_spec, theta, arg_tys, _)+ (univ_tvs, ex_tvs, eq_spec, theta, arg_tys, _) = dataConFullSig data_con- ex_bndrs = dataConExTyVarBinders data_con+ user_bndrs = dataConUserTyVarBinders data_con -- Tidy the univ_tvs of the data constructor to be identical -- to the tyConTyVars of the type constructor. This means@@ -1666,8 +1711,20 @@ con_env1 = (fst tc_env1, mkVarEnv (zipEqual "ifaceConDecl" univ_tvs tc_tyvars)) -- A bit grimy, perhaps, but it's simple! - (con_env2, ex_bndrs') = tidyTyVarBinders con_env1 ex_bndrs+ (con_env2, ex_tvs') = tidyTyCoVarBndrs con_env1 ex_tvs+ user_bndrs' = map (tidyUserTyVarBinder con_env2) user_bndrs to_eq_spec (tv,ty) = (tidyTyVar con_env2 tv, tidyToIfaceType con_env2 ty)++ -- By this point, we have tidied every universal and existential+ -- tyvar. Because of the dcUserTyVarBinders invariant+ -- (see Note [DataCon user type variable binders]), *every*+ -- user-written tyvar must be contained in the substitution that+ -- tidying produced. Therefore, tidying the user-written tyvars is a+ -- simple matter of looking up each variable in the substitution,+ -- which tidyTyVarOcc accomplishes.+ tidyUserTyVarBinder :: TidyEnv -> TyVarBinder -> TyVarBinder+ tidyUserTyVarBinder env (TvBndr tv vis) =+ TvBndr (tidyTyVarOcc env tv) vis classToIfaceDecl :: TidyEnv -> Class -> (TidyEnv, IfaceDecl) classToIfaceDecl env clas
iface/TcIface.hs view
@@ -22,6 +22,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TcTypeNats(typeNatCoAxiomRules) import IfaceSyn import LoadIface@@ -645,7 +647,7 @@ ifIdDetails = details, ifIdInfo = info}) = do { ty <- tcIfaceType iface_type ; details <- tcIdDetails ty details- ; info <- tcIdInfo ignore_prags name ty info+ ; info <- tcIdInfo ignore_prags TopLevel name ty info ; return (AnId (mkGlobalId details name ty info)) } tc_iface_decl _ _ (IfaceData {ifName = tc_name,@@ -892,11 +894,12 @@ IfNewTyCon con -> do { data_con <- tc_con_decl con ; mkNewTyConRhs tycon_name tycon data_con } where- univ_tv_bndrs :: [TyVarBinder]- univ_tv_bndrs = mkDataConUnivTyVarBinders tc_tybinders+ univ_tvs :: [TyVar]+ univ_tvs = binderVars (tyConTyVarBinders tc_tybinders) tc_con_decl (IfCon { ifConInfix = is_infix, ifConExTvs = ex_bndrs,+ ifConUserTvBinders = user_bndrs, ifConName = dc_name, ifConCtxt = ctxt, ifConEqSpec = spec, ifConArgTys = args, ifConFields = lbl_names,@@ -904,9 +907,19 @@ ifConSrcStricts = if_src_stricts}) = -- Universally-quantified tyvars are shared with -- parent TyCon, and are already in scope- bindIfaceForAllBndrs ex_bndrs $ \ ex_tv_bndrs -> do+ bindIfaceTyVars ex_bndrs $ \ ex_tvs -> do { traceIf (text "Start interface-file tc_con_decl" <+> ppr dc_name) + -- By this point, we have bound every universal and existential+ -- tyvar. Because of the dcUserTyVarBinders invariant+ -- (see Note [DataCon user type variable binders]), *every* tyvar in+ -- ifConUserTvBinders has a matching counterpart somewhere in the+ -- bound universals/existentials. As a result, calling tcIfaceTyVar+ -- below is always guaranteed to succeed.+ ; user_tv_bndrs <- mapM (\(TvBndr (name, _) vis) ->+ TvBndr <$> tcIfaceTyVar name <*> pure vis)+ user_bndrs+ -- Read the context and argument types, but lazily for two reasons -- (a) to avoid looking tugging on a recursive use of -- the type itself, which is knot-tied@@ -915,7 +928,14 @@ ; ~(eq_spec, theta, arg_tys, stricts) <- forkM (mk_doc dc_name) $ do { eq_spec <- tcIfaceEqSpec spec ; theta <- tcIfaceCtxt ctxt- ; arg_tys <- mapM tcIfaceType args+ -- This fixes #13710. The enclosing lazy thunk gets+ -- forced when typechecking record wildcard pattern+ -- matching (it's not completely clear why this+ -- tuple is needed), which causes trouble if one of+ -- the argument types was recursively defined.+ -- See also Note [Tying the knot]+ ; arg_tys <- forkM (mk_doc dc_name <+> text "arg_tys")+ $ mapM tcIfaceType args ; stricts <- mapM tc_strict if_stricts -- The IfBang field can mention -- the type itself; hence inside forkM@@ -938,7 +958,7 @@ -- worker. -- See Note [Bangs on imported data constructors] in MkId lbl_names- univ_tv_bndrs ex_tv_bndrs+ univ_tvs ex_tvs user_tv_bndrs eq_spec theta arg_tys orig_res_ty tycon ; traceIf (text "Done interface-file tc_con_decl" <+> ppr dc_name)@@ -1338,6 +1358,8 @@ go (IfaceSubCo c) = SubCo <$> go c go (IfaceAxiomRuleCo ax cos) = AxiomRuleCo <$> go_axiom_rule ax <*> mapM go cos+ go (IfaceFreeCoVar c) = pprPanic "tcIfaceCo:IfaceFreeCoVar" (ppr c)+ go (IfaceHoleCo c) = pprPanic "tcIfaceCo:IfaceHoleCo" (ppr c) go_var :: FastString -> IfL CoVar go_var = tcIfaceLclId@@ -1353,8 +1375,6 @@ tcIfaceUnivCoProv (IfacePhantomProv kco) = PhantomProv <$> tcIfaceCo kco tcIfaceUnivCoProv (IfaceProofIrrelProv kco) = ProofIrrelProv <$> tcIfaceCo kco tcIfaceUnivCoProv (IfacePluginProv str) = return $ PluginProv str-tcIfaceUnivCoProv (IfaceHoleProv _) =- pprPanic "tcIfaceUnivCoProv" (text "holes can't occur in interface files") {- ************************************************************************@@ -1440,7 +1460,7 @@ = do { name <- newIfaceName (mkVarOccFS fs) ; ty' <- tcIfaceType ty ; id_info <- tcIdInfo False {- Don't ignore prags; we are inside one! -}- name ty' info+ NotTopLevel name ty' info ; let id = mkLocalIdOrCoVarWithInfo name ty' id_info `asJoinId_maybe` tcJoinInfo ji ; rhs' <- tcIfaceExpr rhs@@ -1461,7 +1481,7 @@ tc_pair (IfLetBndr _ _ info _, rhs) id = do { rhs' <- tcIfaceExpr rhs ; id_info <- tcIdInfo False {- Don't ignore prags; we are inside one! -}- (idName id) (idType id) info+ NotTopLevel (idName id) (idType id) info ; return (setIdInfo id id_info, rhs') } tcIfaceExpr (IfaceTick tickish expr) = do@@ -1552,8 +1572,8 @@ tyThingPatSyn (AConLike (PatSynCon ps)) = ps tyThingPatSyn _ = panic "tcIdDetails: expecting patsyn" -tcIdInfo :: Bool -> Name -> Type -> IfaceIdInfo -> IfL IdInfo-tcIdInfo ignore_prags name ty info = do+tcIdInfo :: Bool -> TopLevelFlag -> Name -> Type -> IfaceIdInfo -> IfL IdInfo+tcIdInfo ignore_prags toplvl name ty info = do lcl_env <- getLclEnv -- Set the CgInfo to something sensible but uninformative before -- we start; default assumption is that it has CAFs@@ -1574,7 +1594,7 @@ -- The next two are lazy, so they don't transitively suck stuff in tcPrag info (HsUnfold lb if_unf)- = do { unf <- tcUnfolding name ty info if_unf+ = do { unf <- tcUnfolding toplvl name ty info if_unf ; let info1 | lb = info `setOccInfo` strongLoopBreaker | otherwise = info ; return (info1 `setUnfoldingInfo` unf) }@@ -1583,10 +1603,10 @@ tcJoinInfo (IfaceJoinPoint ar) = Just ar tcJoinInfo IfaceNotJoinPoint = Nothing -tcUnfolding :: Name -> Type -> IdInfo -> IfaceUnfolding -> IfL Unfolding-tcUnfolding name _ info (IfCoreUnfold stable if_expr)+tcUnfolding :: TopLevelFlag -> Name -> Type -> IdInfo -> IfaceUnfolding -> IfL Unfolding+tcUnfolding toplvl name _ info (IfCoreUnfold stable if_expr) = do { dflags <- getDynFlags- ; mb_expr <- tcPragExpr name if_expr+ ; mb_expr <- tcPragExpr toplvl name if_expr ; let unf_src | stable = InlineStable | otherwise = InlineRhs ; return $ case mb_expr of@@ -1599,21 +1619,21 @@ where -- Strictness should occur before unfolding! strict_sig = strictnessInfo info-tcUnfolding name _ _ (IfCompulsory if_expr)- = do { mb_expr <- tcPragExpr name if_expr+tcUnfolding toplvl name _ _ (IfCompulsory if_expr)+ = do { mb_expr <- tcPragExpr toplvl name if_expr ; return (case mb_expr of Nothing -> NoUnfolding Just expr -> mkCompulsoryUnfolding expr) } -tcUnfolding name _ _ (IfInlineRule arity unsat_ok boring_ok if_expr)- = do { mb_expr <- tcPragExpr name if_expr+tcUnfolding toplvl name _ _ (IfInlineRule arity unsat_ok boring_ok if_expr)+ = do { mb_expr <- tcPragExpr toplvl name if_expr ; return (case mb_expr of Nothing -> NoUnfolding Just expr -> mkCoreUnfolding InlineStable True expr guidance )} where guidance = UnfWhen { ug_arity = arity, ug_unsat_ok = unsat_ok, ug_boring_ok = boring_ok } -tcUnfolding name dfun_ty _ (IfDFunUnfold bs ops)+tcUnfolding _toplvl name dfun_ty _ (IfDFunUnfold bs ops) = bindIfaceBndrs bs $ \ bs' -> do { mb_ops1 <- forkM_maybe doc $ mapM tcIfaceExpr ops ; return (case mb_ops1 of@@ -1628,13 +1648,14 @@ an unfolding that isn't going to be looked at. -} -tcPragExpr :: Name -> IfaceExpr -> IfL (Maybe CoreExpr)-tcPragExpr name expr+tcPragExpr :: TopLevelFlag -> Name -> IfaceExpr -> IfL (Maybe CoreExpr)+tcPragExpr toplvl name expr = forkM_maybe doc $ do core_expr' <- tcIfaceExpr expr - -- Check for type consistency in the unfolding- whenGOptM Opt_DoCoreLinting $ do+ -- Check for type consistency in the unfolding+ -- See Note [Linting Unfoldings from Interfaces]+ when (isTopLevel toplvl) $ whenGOptM Opt_DoCoreLinting $ do in_scope <- get_in_scope dflags <- getDynFlags case lintUnfolding dflags noSrcLoc in_scope core_expr' of@@ -1692,13 +1713,13 @@ { type_env <- setLclEnv () get_type_env -- yuk ; case lookupNameEnv type_env name of Just thing -> return thing- Nothing ->- pprPanic "tcIfaceGlobal (local): not found"- (ifKnotErr name (if_doc env) type_env)+ -- See Note [Knot-tying fallback on boot]+ Nothing -> via_external } - ; _ -> do-+ ; _ -> via_external }}+ where+ via_external = do { hsc_env <- getTopEnv ; mb_thing <- liftIO (lookupTypeHscEnv hsc_env name) ; case mb_thing of {@@ -1709,21 +1730,7 @@ ; case mb_thing of Failed err -> failIfM err Succeeded thing -> return thing- }}}}}--ifKnotErr :: Name -> SDoc -> TypeEnv -> SDoc-ifKnotErr name env_doc type_env = vcat- [ text "You are in a maze of twisty little passages, all alike."- , text "While forcing the thunk for TyThing" <+> ppr name- , text "which was lazily initialized by" <+> env_doc <> text ","- , text "I tried to tie the knot, but I couldn't find" <+> ppr name- , text "in the current type environment."- , text "If you are developing GHC, please read Note [Tying the knot]"- , text "and Note [Type-checking inside the knot]."- , text "Consider rebuilding GHC with profiling for a better stack trace."- , hang (text "Contents of current type environment:")- 2 (ppr type_env)- ]+ }}} -- Note [Tying the knot] -- ~~~~~~~~~~~~~~~~~~~~~@@ -1738,11 +1745,50 @@ -- * Note [Knot-tying typecheckIface] -- * Note [DFun knot-tying] -- * Note [hsc_type_env_var hack]+-- * Note [Knot-tying fallback on boot] -- -- There is also a wiki page on the subject, see: -- -- https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/TyingTheKnot +-- Note [Knot-tying fallback on boot]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- Suppose that you are typechecking A.hs, which transitively imports,+-- via B.hs, A.hs-boot. When we poke on B.hs and discover that it+-- has a reference to a type T from A, what TyThing should we wire+-- it up with? Clearly, if we have already typechecked T and+-- added it into the type environment, we should go ahead and use that+-- type. But what if we haven't typechecked it yet?+--+-- For the longest time, GHC adopted the policy that this was+-- *an error condition*; that you MUST NEVER poke on B.hs's reference+-- to a T defined in A.hs until A.hs has gotten around to kind-checking+-- T and adding it to the env. However, actually ensuring this is the+-- case has proven to be a bug farm, because it's really difficult to+-- actually ensure this never happens. The problem was especially poignant+-- with type family consistency checks, which eagerly happen before any+-- typechecking takes place.+--+-- Today, we take a different strategy: if we ever try to access+-- an entity from A which doesn't exist, we just fall back on the+-- definition of A from the hs-boot file. This is complicated in+-- its own way: it means that you may end up with a mix of A.hs and+-- A.hs-boot TyThings during the course of typechecking. We don't+-- think (and have not observed) any cases where this would cause+-- problems, but the hypothetical situation one might worry about+-- is something along these lines in Core:+--+-- case x of+-- A -> e1+-- B -> e2+--+-- If, when typechecking this, we find x :: T, and the T we are hooked+-- up with is the abstract one from the hs-boot file, rather than the+-- one defined in this module with constructors A and B. But it's hard+-- to see how this could happen, especially because the reference to+-- the constructor (A and B) means that GHC will always typecheck+-- this expression *after* typechecking T.+ tcIfaceTyConByName :: IfExtName -> IfL TyCon tcIfaceTyConByName name = do { thing <- tcIfaceGlobal name@@ -1828,6 +1874,13 @@ bindIfaceForAllBndr :: IfaceForAllBndr -> (TyVar -> ArgFlag -> IfL a) -> IfL a bindIfaceForAllBndr (TvBndr tv vis) thing_inside = bindIfaceTyVar tv $ \tv' -> thing_inside tv' vis++bindIfaceTyVars :: [IfaceTvBndr] -> ([TyVar] -> IfL a) -> IfL a+bindIfaceTyVars [] thing_inside = thing_inside []+bindIfaceTyVars (tv:tvs) thing_inside+ = bindIfaceTyVar tv $ \tv' ->+ bindIfaceTyVars tvs $ \tvs' ->+ thing_inside (tv' : tvs') bindIfaceTyVar :: IfaceTvBndr -> (TyVar -> IfL a) -> IfL a bindIfaceTyVar (occ,kind) thing_inside
iface/TcIface.hs-boot view
@@ -1,5 +1,6 @@ module TcIface where +import GhcPrelude import IfaceSyn ( IfaceDecl, IfaceClsInst, IfaceFamInst, IfaceRule, IfaceAnnotation, IfaceCompleteMatch ) import TyCoRep ( TyThing )
iface/ToIface.hs view
@@ -22,7 +22,7 @@ , tidyToIfaceContext , tidyToIfaceTcArgs -- * Coercions- , toIfaceCoercion+ , toIfaceCoercion, toIfaceCoercionX -- * Pattern synonyms , patSynToIfaceDecl -- * Expressions@@ -44,6 +44,8 @@ #include "HsVersions.h" +import GhcPrelude+ import IfaceSyn import DataCon import Id@@ -137,15 +139,11 @@ , n_tys == 2*arity = IfaceTupleTy BoxedTuple IsPromoted (toIfaceTcArgsX fr tc (drop arity tys)) - -- type equalities: see Note [Equality predicates in IfaceType]- | tyConName tc == eqTyConName- = let info = IfaceTyConInfo IsNotPromoted (IfaceEqualityTyCon True)- in IfaceTyConApp (IfaceTyCon (tyConName tc) info) (toIfaceTcArgsX fr tc tys)- | tc `elem` [ eqPrimTyCon, eqReprPrimTyCon, heqTyCon ]- , [k1, k2, _t1, _t2] <- tys- = let homogeneous = k1 `eqType` k2- info = IfaceTyConInfo IsNotPromoted (IfaceEqualityTyCon homogeneous)+ , (k1:k2:_) <- tys+ = let info = IfaceTyConInfo IsNotPromoted sort+ sort | k1 `eqType` k2 = IfaceEqualityTyCon+ | otherwise = IfaceNormalTyCon in IfaceTyConApp (IfaceTyCon (tyConName tc) info) (toIfaceTcArgsX fr tc tys) -- other applications@@ -216,8 +214,13 @@ toIfaceCoercionX fr co = go co where- go (Refl r ty) = IfaceReflCo r (toIfaceType ty)- go (CoVarCo cv) = IfaceCoVarCo (toIfaceCoVar cv)+ go (Refl r ty) = IfaceReflCo r (toIfaceTypeX fr ty)+ go (CoVarCo cv)+ -- See [TcTyVars in IfaceType] in IfaceType+ | cv `elemVarSet` fr = IfaceFreeCoVar cv+ | otherwise = IfaceCoVarCo (toIfaceCoVar cv)+ go (HoleCo h) = IfaceHoleCo (coHoleCoVar h)+ go (AppCo co1 co2) = IfaceAppCo (go co1) (go co2) go (SymCo co) = IfaceSymCo (go co) go (TransCo co1 co2) = IfaceTransCo (go co1) (go co2)@@ -236,8 +239,7 @@ | tc `hasKey` funTyConKey , [_,_,_,_] <- cos = pprPanic "toIfaceCoercion" (ppr co) | otherwise = IfaceTyConAppCo r (toIfaceTyCon tc) (map go cos)- go (FunCo r co1 co2) = IfaceFunCo r (toIfaceCoercion co1)- (toIfaceCoercion co2)+ go (FunCo r co1 co2) = IfaceFunCo r (go co1) (go co2) go (ForAllCo tv k co) = IfaceForAllCo (toIfaceTvBndr tv) (toIfaceCoercionX fr' k)@@ -250,14 +252,13 @@ go_prov (PhantomProv co) = IfacePhantomProv (go co) go_prov (ProofIrrelProv co) = IfaceProofIrrelProv (go co) go_prov (PluginProv str) = IfacePluginProv str- go_prov (HoleProv h) = IfaceHoleProv (chUnique h) toIfaceTcArgs :: TyCon -> [Type] -> IfaceTcArgs toIfaceTcArgs = toIfaceTcArgsX emptyVarSet toIfaceTcArgsX :: VarSet -> TyCon -> [Type] -> IfaceTcArgs -- See Note [Suppressing invisible arguments]--- We produce a result list of args describing visiblity+-- We produce a result list of args describing visibility -- The awkward case is -- T :: forall k. * -> k -- And consider
iface/ToIface.hs-boot view
@@ -1,17 +1,16 @@ module ToIface where import {-# SOURCE #-} TyCoRep-import {-# SOURCE #-} IfaceType-import Var ( TyVar, TyVarBinder )+import {-# SOURCE #-} IfaceType( IfaceType, IfaceTyCon, IfaceForAllBndr+ , IfaceCoercion, IfaceTyLit, IfaceTcArgs )+import Var ( TyVarBinder ) import TyCon ( TyCon ) import VarSet( VarSet ) -- For TyCoRep-toIfaceType :: Type -> IfaceType toIfaceTypeX :: VarSet -> Type -> IfaceType toIfaceTyLit :: TyLit -> IfaceTyLit toIfaceForAllBndr :: TyVarBinder -> IfaceForAllBndr-toIfaceTvBndr :: TyVar -> IfaceTvBndr toIfaceTyCon :: TyCon -> IfaceTyCon toIfaceTcArgs :: TyCon -> [Type] -> IfaceTcArgs-toIfaceCoercion :: Coercion -> IfaceCoercion+toIfaceCoercionX :: VarSet -> Coercion -> IfaceCoercion
llvmGen/Llvm/AbsSyn.hs view
@@ -4,6 +4,8 @@ module Llvm.AbsSyn where +import GhcPrelude+ import Llvm.MetaData import Llvm.Types @@ -106,7 +108,7 @@ -- | Llvm Statements data LlvmStatement {- |- Assign an expression to an variable:+ Assign an expression to a variable: * dest: Variable to assign to * source: Source expression -}@@ -258,7 +260,7 @@ | ALoad LlvmSyncOrdering SingleThreaded LlvmVar {- |- Navigate in an structure, selecting elements+ Navigate in a structure, selecting elements * inbound: Is the pointer inbounds? (computed pointer doesn't overflow) * ptr: Location of the structure * indexes: A list of indexes to select the correct value.@@ -267,7 +269,7 @@ {- | Cast the variable from to the to type. This is an abstraction of three- cast operators in Llvm, inttoptr, prttoint and bitcast.+ cast operators in Llvm, inttoptr, ptrtoint and bitcast. * cast: Cast type * from: Variable to cast * to: type to cast to@@ -323,8 +325,8 @@ basic block in a new variable of type tp. * tp: type of the merged variable, must match the types of the predecessor variables.- * precessors: A list of variables and the basic block that they originate- from.+ * predecessors: A list of variables and the basic block that they originate+ from. -} | Phi LlvmType [(LlvmVar,LlvmVar)]
llvmGen/Llvm/MetaData.hs view
@@ -2,6 +2,8 @@ module Llvm.MetaData where +import GhcPrelude+ import Llvm.Types import Outputable
llvmGen/Llvm/PpLlvm.hs view
@@ -25,6 +25,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Llvm.AbsSyn import Llvm.MetaData import Llvm.Types@@ -238,7 +240,7 @@ Malloc tp amount -> ppMalloc tp amount AtomicRMW aop tgt src ordering -> ppAtomicRMW aop tgt src ordering CmpXChg addr old new s_ord f_ord -> ppCmpXChg addr old new s_ord f_ord- Phi tp precessors -> ppPhi tp precessors+ Phi tp predecessors -> ppPhi tp predecessors Asm asm c ty v se sk -> ppAsm asm c ty v se sk MExpr meta expr -> ppMetaExpr meta expr
llvmGen/Llvm/Types.hs view
@@ -8,6 +8,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Data.Char import Data.Int import Numeric@@ -868,7 +870,7 @@ -- | Reverse or leave byte data alone to fix endianness on this target. fixEndian :: [a] -> [a]-#ifdef WORDS_BIGENDIAN+#if defined(WORDS_BIGENDIAN) fixEndian = id #else fixEndian = reverse
llvmGen/LlvmCodeGen.hs view
@@ -7,6 +7,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Llvm import LlvmCodeGen.Base import LlvmCodeGen.CodeGen@@ -19,7 +21,8 @@ import CgUtils ( fixStgRegisters ) import Cmm import CmmUtils-import Hoopl+import Hoopl.Block+import Hoopl.Collections import PprCmm import BufWrite@@ -71,7 +74,7 @@ llvmCodeGen' :: Stream.Stream LlvmM RawCmmGroup () -> LlvmM () llvmCodeGen' cmm_stream = do -- Preamble- renderLlvm pprLlvmHeader+ renderLlvm header ghcInternalFunctions cmmMetaLlvmPrelude @@ -84,6 +87,15 @@ -- Postamble cmmUsedLlvmGens+ where+ header :: SDoc+ header = sdocWithDynFlags $ \dflags ->+ let target = LLVM_TARGET+ layout = case lookup target (llvmTargets dflags) of+ Just (LlvmTarget dl _ _) -> dl+ Nothing -> error $ "Failed to lookup the datalayout for " ++ target ++ "; available targets: " ++ show (map fst $ llvmTargets dflags)+ in text ("target datalayout = \"" ++ layout ++ "\"")+ $+$ text ("target triple = \"" ++ target ++ "\"") llvmGroupLlvmGens :: RawCmmGroup -> LlvmM () llvmGroupLlvmGens cmm = do
llvmGen/LlvmCodeGen/Base.hs view
@@ -37,6 +37,8 @@ #include "HsVersions.h" #include "ghcautoconf.h" +import GhcPrelude+ import Llvm import LlvmCodeGen.Regs
llvmGen/LlvmCodeGen/CodeGen.hs view
@@ -7,6 +7,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Llvm import LlvmCodeGen.Base import LlvmCodeGen.Regs@@ -18,7 +20,9 @@ import PprCmm import CmmUtils import CmmSwitch-import Hoopl+import Hoopl.Block+import Hoopl.Graph+import Hoopl.Collections import DynFlags import FastString@@ -34,16 +38,16 @@ import Control.Monad.Trans.Class import Control.Monad.Trans.Writer -#if __GLASGOW_HASKELL__ > 710 import Data.Semigroup ( Semigroup ) import qualified Data.Semigroup as Semigroup-#endif import Data.List ( nub ) import Data.Maybe ( catMaybes ) type Atomic = Bool type LlvmStatements = OrdList LlvmStatement +data Signage = Signed | Unsigned deriving (Eq, Show)+ -- ----------------------------------------------------------------------------- -- | Top-level of the LLVM proc Code generator --@@ -62,7 +66,7 @@ -- -- | Generate code for a list of blocks that make up a complete--- procedure. The first block in the list is exepected to be the entry+-- procedure. The first block in the list is expected to be the entry -- point and will get the prologue. basicBlocksCodeGen :: LiveGlobalRegs -> [CmmBlock] -> LlvmM ([LlvmBasicBlock], [LlvmCmmDecl])@@ -205,7 +209,7 @@ let args_hints' = zip args arg_hints argVars <- arg_varsW args_hints' ([], nilOL, []) fptr <- liftExprData $ getFunPtr funTy t- argVars' <- castVarsW $ zip argVars argTy+ argVars' <- castVarsW Signed $ zip argVars argTy doTrashStmts let argSuffix = [mkIntLit i32 0, mkIntLit i32 localityInt, mkIntLit i32 1]@@ -216,6 +220,11 @@ -- and return types genCall t@(PrimTarget (MO_PopCnt w)) dsts args = genCallSimpleCast w t dsts args++genCall t@(PrimTarget (MO_Pdep w)) dsts args =+ genCallSimpleCast2 w t dsts args+genCall t@(PrimTarget (MO_Pext w)) dsts args =+ genCallSimpleCast2 w t dsts args genCall t@(PrimTarget (MO_Clz w)) dsts args = genCallSimpleCast w t dsts args genCall t@(PrimTarget (MO_Ctz w)) dsts args =@@ -283,7 +292,7 @@ let args_hints = zip args arg_hints argVars <- arg_varsW args_hints ([], nilOL, []) fptr <- getFunPtrW funTy t- argVars' <- castVarsW $ zip argVars argTy+ argVars' <- castVarsW Signed $ zip argVars argTy doTrashStmts let alignVal = mkIntLit i32 align@@ -506,7 +515,7 @@ :: ForeignTarget -- ^ PrimOp -> Width -- ^ Width of the operands. -> (CmmActual, CmmActual) -- ^ Actual arguments.- -> (LlvmType, LlvmType) -- ^ LLLVM types of the returned sturct.+ -> (LlvmType, LlvmType) -- ^ LLVM types of the returned struct. -> LlvmM (LlvmVar, LlvmVar, StmtData) genCallExtract target@(PrimTarget op) w (argA, argB) (llvmTypeA, llvmTypeB) = do let width = widthToLlvmInt w@@ -516,7 +525,7 @@ -- Process the arguments. let args_hints = zip [argA, argB] (snd $ foreignTargetHints target) (argsV1, args1, top1) <- arg_vars args_hints ([], nilOL, [])- (argsV2, args2) <- castVars $ zip argsV1 argTy+ (argsV2, args2) <- castVars Signed $ zip argsV1 argTy -- Get the function and make the call. fname <- cmmPrimOpFunctions op@@ -556,9 +565,9 @@ let (_, arg_hints) = foreignTargetHints t let args_hints = zip args arg_hints (argsV, stmts2, top2) <- arg_vars args_hints ([], nilOL, [])- (argsV', stmts4) <- castVars $ zip argsV [width]+ (argsV', stmts4) <- castVars Signed $ zip argsV [width] (retV, s1) <- doExpr width $ Call StdCall fptr argsV' []- ([retV'], stmts5) <- castVars [(retV,dstTy)]+ ([retV'], stmts5) <- castVars (cmmPrimOpRetValSignage op) [(retV,dstTy)] let s2 = Store retV' dstV let stmts = stmts2 `appOL` stmts4 `snocOL`@@ -567,6 +576,37 @@ genCallSimpleCast _ _ dsts _ = panic ("genCallSimpleCast: " ++ show (length dsts) ++ " dsts") +-- Handle simple function call that only need simple type casting, of the form:+-- truncate arg >>= \a -> call(a) >>= zext+--+-- since GHC only really has i32 and i64 types and things like Word8 are backed+-- by an i32 and just present a logical i8 range. So we must handle conversions+-- from i32 to i8 explicitly as LLVM is strict about types.+genCallSimpleCast2 :: Width -> ForeignTarget -> [CmmFormal] -> [CmmActual]+ -> LlvmM StmtData+genCallSimpleCast2 w t@(PrimTarget op) [dst] args = do+ let width = widthToLlvmInt w+ dstTy = cmmToLlvmType $ localRegType dst++ fname <- cmmPrimOpFunctions op+ (fptr, _, top3) <- getInstrinct fname width (const width <$> args)++ dstV <- getCmmReg (CmmLocal dst)++ let (_, arg_hints) = foreignTargetHints t+ let args_hints = zip args arg_hints+ (argsV, stmts2, top2) <- arg_vars args_hints ([], nilOL, [])+ (argsV', stmts4) <- castVars Signed $ zip argsV (const width <$> argsV)+ (retV, s1) <- doExpr width $ Call StdCall fptr argsV' []+ ([retV'], stmts5) <- castVars (cmmPrimOpRetValSignage op) [(retV,dstTy)]+ let s2 = Store retV' dstV++ let stmts = stmts2 `appOL` stmts4 `snocOL`+ s1 `appOL` stmts5 `snocOL` s2+ return (stmts, top2 ++ top3)+genCallSimpleCast2 _ _ dsts _ =+ panic ("genCallSimpleCast2: " ++ show (length dsts) ++ " dsts")+ -- | Create a function pointer from a target. getFunPtrW :: (LMString -> LlvmType) -> ForeignTarget -> WriterT LlvmAccum LlvmM LlvmVar@@ -636,31 +676,32 @@ -- | Cast a collection of LLVM variables to specific types.-castVarsW :: [(LlvmVar, LlvmType)]+castVarsW :: Signage+ -> [(LlvmVar, LlvmType)] -> WriterT LlvmAccum LlvmM [LlvmVar]-castVarsW vars = do- (vars, stmts) <- lift $ castVars vars+castVarsW signage vars = do+ (vars, stmts) <- lift $ castVars signage vars tell $ LlvmAccum stmts mempty return vars -- | Cast a collection of LLVM variables to specific types.-castVars :: [(LlvmVar, LlvmType)]+castVars :: Signage -> [(LlvmVar, LlvmType)] -> LlvmM ([LlvmVar], LlvmStatements)-castVars vars = do- done <- mapM (uncurry castVar) vars+castVars signage vars = do+ done <- mapM (uncurry (castVar signage)) vars let (vars', stmts) = unzip done return (vars', toOL stmts) -- | Cast an LLVM variable to a specific type, panicing if it can't be done.-castVar :: LlvmVar -> LlvmType -> LlvmM (LlvmVar, LlvmStatement)-castVar v t | getVarType v == t+castVar :: Signage -> LlvmVar -> LlvmType -> LlvmM (LlvmVar, LlvmStatement)+castVar signage v t | getVarType v == t = return (v, Nop) | otherwise = do dflags <- getDynFlags let op = case (getVarType v, t) of (LMInt n, LMInt m)- -> if n < m then LM_Sext else LM_Trunc+ -> if n < m then extend else LM_Trunc (vt, _) | isFloat vt && isFloat t -> if llvmWidthInBits dflags vt < llvmWidthInBits dflags t then LM_Fpext else LM_Fptrunc@@ -674,8 +715,17 @@ (vt, _) -> panic $ "castVars: Can't cast this type (" ++ showSDoc dflags (ppr vt) ++ ") to (" ++ showSDoc dflags (ppr t) ++ ")" doExpr t $ Cast op v t+ where extend = case signage of+ Signed -> LM_Sext+ Unsigned -> LM_Zext +cmmPrimOpRetValSignage :: CallishMachOp -> Signage+cmmPrimOpRetValSignage mop = case mop of+ MO_Pdep _ -> Unsigned+ MO_Pext _ -> Unsigned+ _ -> Signed+ -- | Decide what C function to use to implement a CallishMachOp cmmPrimOpFunctions :: CallishMachOp -> LlvmM LMString cmmPrimOpFunctions mop = do@@ -726,12 +776,22 @@ MO_Memcpy _ -> fsLit $ "llvm.memcpy." ++ intrinTy1 MO_Memmove _ -> fsLit $ "llvm.memmove." ++ intrinTy1 MO_Memset _ -> fsLit $ "llvm.memset." ++ intrinTy2+ MO_Memcmp _ -> fsLit $ "memcmp" (MO_PopCnt w) -> fsLit $ "llvm.ctpop." ++ showSDoc dflags (ppr $ widthToLlvmInt w) (MO_BSwap w) -> fsLit $ "llvm.bswap." ++ showSDoc dflags (ppr $ widthToLlvmInt w) (MO_Clz w) -> fsLit $ "llvm.ctlz." ++ showSDoc dflags (ppr $ widthToLlvmInt w) (MO_Ctz w) -> fsLit $ "llvm.cttz." ++ showSDoc dflags (ppr $ widthToLlvmInt w) + (MO_Pdep w) -> let w' = showSDoc dflags (ppr $ widthInBits w)+ in if isBmi2Enabled dflags+ then fsLit $ "llvm.x86.bmi.pdep." ++ w'+ else fsLit $ "hs_pdep" ++ w'+ (MO_Pext w) -> let w' = showSDoc dflags (ppr $ widthInBits w)+ in if isBmi2Enabled dflags+ then fsLit $ "llvm.x86.bmi.pext." ++ w'+ else fsLit $ "hs_pext" ++ w'+ (MO_Prefetch_Data _ )-> fsLit "llvm.prefetch" MO_AddIntC w -> fsLit $ "llvm.sadd.with.overflow."@@ -986,7 +1046,7 @@ However, it's certainly possible and reasonable for this to occur in hand-written C-- code. Consider something like: - #ifndef SOME_CONDITIONAL+ #if !defined(SOME_CONDITIONAL) #define CHECK_THING(x) 1 #else #define CHECK_THING(x) some_operation((x))@@ -1137,6 +1197,8 @@ all0s = LMLitVar $ LMVectorLit (replicate len all0) in negateVec vecty all0s LM_MO_FSub + MO_AlignmentCheck _ _ -> panic "-falignment-sanitisation is not supported by -fllvm"+ -- Handle unsupported cases explicitly so we get a warning -- of missing case when new MachOps added MO_Add _ -> panicOp@@ -1207,7 +1269,7 @@ negateVec ty v2 negOp = do (vx, stmts1, top) <- exprToVar x- ([vx'], stmts2) <- castVars [(vx, ty)]+ ([vx'], stmts2) <- castVars Signed [(vx, ty)] (v1, s1) <- doExpr ty $ LlvmOp negOp v2 vx' return (v1, stmts1 `appOL` stmts2 `snocOL` s1, top) @@ -1270,7 +1332,7 @@ genMachOp_slow _ (MO_V_Extract l w) [val, idx] = runExprData $ do vval <- exprToVarW val vidx <- exprToVarW idx- [vval'] <- castVarsW [(vval, LMVector l ty)]+ [vval'] <- castVarsW Signed [(vval, LMVector l ty)] doExprW ty $ Extract vval' vidx where ty = widthToLlvmInt w@@ -1278,7 +1340,7 @@ genMachOp_slow _ (MO_VF_Extract l w) [val, idx] = runExprData $ do vval <- exprToVarW val vidx <- exprToVarW idx- [vval'] <- castVarsW [(vval, LMVector l ty)]+ [vval'] <- castVarsW Signed [(vval, LMVector l ty)] doExprW ty $ Extract vval' vidx where ty = widthToLlvmFloat w@@ -1288,7 +1350,7 @@ vval <- exprToVarW val velt <- exprToVarW elt vidx <- exprToVarW idx- [vval'] <- castVarsW [(vval, ty)]+ [vval'] <- castVarsW Signed [(vval, ty)] doExprW ty $ Insert vval' velt vidx where ty = LMVector l (widthToLlvmInt w)@@ -1297,7 +1359,7 @@ vval <- exprToVarW val velt <- exprToVarW elt vidx <- exprToVarW idx- [vval'] <- castVarsW [(vval, ty)]+ [vval'] <- castVarsW Signed [(vval, ty)] doExprW ty $ Insert vval' velt vidx where ty = LMVector l (widthToLlvmFloat w)@@ -1386,6 +1448,8 @@ MO_VF_Neg {} -> panicOp + MO_AlignmentCheck {} -> panicOp+ where binLlvmOp ty binOp = runExprData $ do vx <- exprToVarW x@@ -1407,7 +1471,7 @@ binCastLlvmOp ty binOp = runExprData $ do vx <- exprToVarW x vy <- exprToVarW y- [vx', vy'] <- castVarsW [(vx, ty), (vy, ty)]+ [vx', vy'] <- castVarsW Signed [(vx, ty), (vy, ty)] doExprW ty $ binOp vx' vy' -- | Need to use EOption here as Cmm expects word size results from@@ -1861,16 +1925,13 @@ -- | A more convenient way of accumulating LLVM statements and declarations. data LlvmAccum = LlvmAccum LlvmStatements [LlvmCmmDecl] -#if __GLASGOW_HASKELL__ > 710 instance Semigroup LlvmAccum where LlvmAccum stmtsA declsA <> LlvmAccum stmtsB declsB = LlvmAccum (stmtsA Semigroup.<> stmtsB) (declsA Semigroup.<> declsB)-#endif instance Monoid LlvmAccum where mempty = LlvmAccum nilOL []- LlvmAccum stmtsA declsA `mappend` LlvmAccum stmtsB declsB =- LlvmAccum (stmtsA `mappend` stmtsB) (declsA `mappend` declsB)+ mappend = (Semigroup.<>) liftExprData :: LlvmM ExprData -> WriterT LlvmAccum LlvmM LlvmVar liftExprData action = do
llvmGen/LlvmCodeGen/Data.hs view
@@ -9,6 +9,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Llvm import LlvmCodeGen.Base @@ -56,29 +58,23 @@ return ([globDef], [tyAlias]) --- | Should a data in this section be considered constant-isSecConstant :: Section -> Bool-isSecConstant (Section t _) = case t of- Text -> True- ReadOnlyData -> True- RelocatableReadOnlyData -> True- ReadOnlyData16 -> True- CString -> True- Data -> False- UninitialisedData -> False- (OtherSection _) -> False- -- | Format the section type part of a Cmm Section llvmSectionType :: Platform -> SectionType -> FastString llvmSectionType p t = case t of Text -> fsLit ".text"- ReadOnlyData -> fsLit ".rodata"- RelocatableReadOnlyData -> fsLit ".data.rel.ro"- ReadOnlyData16 -> fsLit ".rodata.cst16"+ ReadOnlyData -> case platformOS p of+ OSMinGW32 -> fsLit ".rdata"+ _ -> fsLit ".rodata"+ RelocatableReadOnlyData -> case platformOS p of+ OSMinGW32 -> fsLit ".rdata$rel.ro"+ _ -> fsLit ".data.rel.ro"+ ReadOnlyData16 -> case platformOS p of+ OSMinGW32 -> fsLit ".rdata$cst16"+ _ -> fsLit ".rodata.cst16" Data -> fsLit ".data" UninitialisedData -> fsLit ".bss" CString -> case platformOS p of- OSMinGW32 -> fsLit ".rdata"+ OSMinGW32 -> fsLit ".rdata$str" _ -> fsLit ".rodata.str" (OtherSection _) -> panic "llvmSectionType: unknown section type" @@ -92,7 +88,11 @@ then return Nothing else do lmsuffix <- strCLabel_llvm suffix- return (Just (concatFS [llvmSectionType platform t, fsLit ".", lmsuffix]))+ let result sep = Just (concatFS [llvmSectionType platform t+ , fsLit sep, lmsuffix])+ case platformOS platform of+ OSMinGW32 -> return (result "$")+ _ -> return (result ".") -- ---------------------------------------------------------------------------- -- * Generate static data
llvmGen/LlvmCodeGen/Ppr.hs view
@@ -4,87 +4,27 @@ -- | Pretty print helpers for the LLVM Code generator. -- module LlvmCodeGen.Ppr (- pprLlvmHeader, pprLlvmCmmDecl, pprLlvmData, infoSection+ pprLlvmCmmDecl, pprLlvmData, infoSection ) where #include "HsVersions.h" +import GhcPrelude+ import Llvm import LlvmCodeGen.Base import LlvmCodeGen.Data import CLabel import Cmm-import Platform import FastString import Outputable import Unique - -- ---------------------------------------------------------------------------- -- * Top level ------ | Header code for LLVM modules-pprLlvmHeader :: SDoc-pprLlvmHeader = moduleLayout----- | LLVM module layout description for the host target-moduleLayout :: SDoc-moduleLayout = sdocWithPlatform $ \platform ->- case platform of- Platform { platformArch = ArchX86, platformOS = OSDarwin } ->- text "target datalayout = \"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32\""- $+$ text "target triple = \"i386-apple-darwin9.8\""- Platform { platformArch = ArchX86, platformOS = OSMinGW32 } ->- text "target datalayout = \"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32\""- $+$ text "target triple = \"i686-pc-win32\""- Platform { platformArch = ArchX86, platformOS = OSLinux } ->- text "target datalayout = \"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32\""- $+$ text "target triple = \"i386-pc-linux-gnu\""- Platform { platformArch = ArchX86_64, platformOS = OSDarwin } ->- text "target datalayout = \"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64\""- $+$ text "target triple = \"x86_64-apple-darwin10.0.0\""- Platform { platformArch = ArchX86_64, platformOS = OSLinux } ->- text "target datalayout = \"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64\""- $+$ text "target triple = \"x86_64-linux-gnu\""- Platform { platformArch = ArchARM {}, platformOS = OSLinux } ->- text "target datalayout = \"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32\""- $+$ text "target triple = \"armv6-unknown-linux-gnueabihf\""- Platform { platformArch = ArchARM {}, platformOS = OSAndroid } ->- text "target datalayout = \"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32\""- $+$ text "target triple = \"arm-unknown-linux-androideabi\""- Platform { platformArch = ArchARM {}, platformOS = OSQNXNTO } ->- text "target datalayout = \"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32\""- $+$ text "target triple = \"arm-unknown-nto-qnx8.0.0eabi\""- Platform { platformArch = ArchARM {}, platformOS = OSiOS } ->- text "target datalayout = \"e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32\""- $+$ text "target triple = \"thumbv7-apple-ios7.0.0\""- Platform { platformArch = ArchARM64, platformOS = OSiOS } ->- text "target datalayout = \"e-m:o-i64:64-i128:128-n32:64-S128\""- $+$ text "target triple = \"arm64-apple-ios7.0.0\""- Platform { platformArch = ArchX86, platformOS = OSiOS } ->- text "target datalayout = \"e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128\""- $+$ text "target triple = \"i386-apple-ios7.0.0\""- Platform { platformArch = ArchX86_64, platformOS = OSiOS } ->- text "target datalayout = \"e-m:o-i64:64-f80:128-n8:16:32:64-S128\""- $+$ text "target triple = \"x86_64-apple-ios7.0.0\""- Platform { platformArch = ArchARM64, platformOS = OSLinux } ->- text "target datalayout = \"e-m:e-i64:64-i128:128-n32:64-S128\""- $+$ text "target triple = \"aarch64-unknown-linux-gnu\""- _ ->- if platformIsCrossCompiling platform- then panic "LlvmCodeGen.Ppr: Cross compiling without valid target info."- else empty- -- If you see the above panic, GHC is missing the required target datalayout- -- and triple information. You can obtain this info by compiling a simple- -- 'hello world' C program with the clang C compiler eg:- -- clang -S hello.c -emit-llvm -o -- -- and the first two lines of hello.ll should provide the 'target datalayout'- -- and 'target triple' lines required.- -- | Pretty print LLVM data code pprLlvmData :: LlvmData -> SDoc
llvmGen/LlvmCodeGen/Regs.hs view
@@ -11,6 +11,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Llvm import CmmExpr
llvmGen/LlvmMangler.hs view
@@ -11,6 +11,8 @@ module LlvmMangler ( llvmFixupAsm ) where +import GhcPrelude+ import DynFlags ( DynFlags, targetPlatform ) import Platform ( platformArch, Arch(..) ) import ErrUtils ( withTiming )
main/Annotations.hs view
@@ -17,6 +17,8 @@ deserializeAnns ) where +import GhcPrelude+ import Binary import Module ( Module ) import Name
+ main/Ar.hs view
@@ -0,0 +1,260 @@+{-# LANGUAGE OverloadedStrings, GeneralizedNewtypeDeriving, CPP #-}+{- Note: [The need for Ar.hs]+Building `-staticlib` required the presence of libtool, and was a such+restricted to mach-o only. As libtool on macOS and gnu libtool are very+different, there was no simple portable way to support this.++libtool for static archives does essentially: concatinate the input archives,+add the input objects, and create a symbol index. Using `ar` for this task+fails as even `ar` (bsd and gnu, llvm, ...) do not provide the same+features across platforms (e.g. index prefixed retrieval of objects with+the same name.)++As Archives are rather simple structurally, we can just build the archives+with Haskell directly and use ranlib on the final result to get the symbol+index. This should allow us to work around with the differences/abailability+of libtool across differet platforms.+-}+module Ar+ (ArchiveEntry(..)+ ,Archive(..)+ ,afilter++ ,parseAr++ ,loadAr+ ,loadObj+ ,writeBSDAr+ ,writeGNUAr++ ,isBSDSymdef+ ,isGNUSymdef+ )+ where++import GhcPrelude++import Data.Semigroup (Semigroup)+import Data.List (mapAccumL, isPrefixOf)+import Data.Monoid ((<>))+import Data.Binary.Get+import Data.Binary.Put+import Control.Monad+import Control.Applicative+import qualified Data.ByteString as B+import qualified Data.ByteString.Char8 as C+import qualified Data.ByteString.Lazy as L+#if !defined(mingw32_HOST_OS)+import qualified System.Posix.Files as POSIX+#endif+import System.FilePath (takeFileName)++data ArchiveEntry = ArchiveEntry+ { filename :: String -- ^ File name.+ , filetime :: Int -- ^ File modification time.+ , fileown :: Int -- ^ File owner.+ , filegrp :: Int -- ^ File group.+ , filemode :: Int -- ^ File mode.+ , filesize :: Int -- ^ File size.+ , filedata :: B.ByteString -- ^ File bytes.+ } deriving (Eq, Show)++newtype Archive = Archive [ArchiveEntry]+ deriving (Eq, Show, Semigroup, Monoid)++afilter :: (ArchiveEntry -> Bool) -> Archive -> Archive+afilter f (Archive xs) = Archive (filter f xs)++isBSDSymdef, isGNUSymdef :: ArchiveEntry -> Bool+isBSDSymdef a = "__.SYMDEF" `isPrefixOf` (filename a)+isGNUSymdef a = "/" == (filename a)++-- | Archives have numeric values padded with '\x20' to the right.+getPaddedInt :: B.ByteString -> Int+getPaddedInt = read . C.unpack . C.takeWhile (/= '\x20')++putPaddedInt :: Int -> Int -> Put+putPaddedInt padding i = putPaddedString '\x20' padding (show i)++putPaddedString :: Char -> Int -> String -> Put+putPaddedString pad padding s = putByteString . C.pack . take padding $ s `mappend` (repeat pad)++getBSDArchEntries :: Get [ArchiveEntry]+getBSDArchEntries = do+ empty <- isEmpty+ if empty then+ return []+ else do+ name <- getByteString 16+ when ('/' `C.elem` name && C.take 3 name /= "#1/") $+ fail "Looks like GNU Archive"+ time <- getPaddedInt <$> getByteString 12+ own <- getPaddedInt <$> getByteString 6+ grp <- getPaddedInt <$> getByteString 6+ mode <- getPaddedInt <$> getByteString 8+ st_size <- getPaddedInt <$> getByteString 10+ end <- getByteString 2+ when (end /= "\x60\x0a") $+ fail "Invalid archive header end marker"+ off1 <- liftM fromIntegral bytesRead :: Get Int+ -- BSD stores extended filenames, by writing #1/<length> into the+ -- name field, the first @length@ bytes then represent the file name+ -- thus the payload size is filesize + file name length.+ name <- if C.unpack (C.take 3 name) == "#1/" then+ liftM (C.unpack . C.takeWhile (/= '\0')) (getByteString $ read $ C.unpack $ C.drop 3 name)+ else+ return $ C.unpack $ C.takeWhile (/= ' ') name+ off2 <- liftM fromIntegral bytesRead :: Get Int+ file <- getByteString (st_size - (off2 - off1))+ rest <- getBSDArchEntries+ return $ (ArchiveEntry name time own grp mode (st_size - (off2 - off1)) file) : rest++-- | GNU Archives feature a special '//' entry that contains the+-- extended names. Those are referred to as /<num>, where num is the+-- offset into the '//' entry.+-- In addition, filenames are terminated with '/' in the archive.+getGNUArchEntries :: Maybe ArchiveEntry -> Get [ArchiveEntry]+getGNUArchEntries extInfo = do+ empty <- isEmpty+ if empty+ then return []+ else+ do+ name <- getByteString 16+ time <- getPaddedInt <$> getByteString 12+ own <- getPaddedInt <$> getByteString 6+ grp <- getPaddedInt <$> getByteString 6+ mode <- getPaddedInt <$> getByteString 8+ st_size <- getPaddedInt <$> getByteString 10+ end <- getByteString 2+ when (end /= "\x60\x0a") $+ fail "Invalid archive header end marker"+ file <- getByteString st_size+ name <- return . C.unpack $+ if C.unpack (C.take 1 name) == "/"+ then case C.takeWhile (/= ' ') name of+ name@"/" -> name -- symbol table+ name@"//" -> name -- extendedn file names table+ name -> getExtName extInfo (read . C.unpack $ C.drop 1 name)+ else C.takeWhile (/= '/') name+ case name of+ "/" -> getGNUArchEntries extInfo+ "//" -> getGNUArchEntries (Just (ArchiveEntry name time own grp mode st_size file))+ _ -> (ArchiveEntry name time own grp mode st_size file :) <$> getGNUArchEntries extInfo++ where+ getExtName :: Maybe ArchiveEntry -> Int -> B.ByteString+ getExtName Nothing _ = error "Invalid extended filename reference."+ getExtName (Just info) offset = C.takeWhile (/= '/') . C.drop offset $ filedata info++-- | put an Archive Entry. This assumes that the entries+-- have been preprocessed to account for the extenden file name+-- table section "//" e.g. for GNU Archives. Or that the names+-- have been move into the payload for BSD Archives.+putArchEntry :: ArchiveEntry -> PutM ()+putArchEntry (ArchiveEntry name time own grp mode st_size file) = do+ putPaddedString ' ' 16 name+ putPaddedInt 12 time+ putPaddedInt 6 own+ putPaddedInt 6 grp+ putPaddedInt 8 mode+ putPaddedInt 10 (st_size + pad)+ putByteString "\x60\x0a"+ putByteString file+ when (pad == 1) $+ putWord8 0x0a+ where+ pad = st_size `mod` 2++getArchMagic :: Get ()+getArchMagic = do+ magic <- liftM C.unpack $ getByteString 8+ if magic /= "!<arch>\n"+ then fail $ "Invalid magic number " ++ show magic+ else return ()++putArchMagic :: Put+putArchMagic = putByteString $ C.pack "!<arch>\n"++getArch :: Get Archive+getArch = Archive <$> do+ getArchMagic+ getBSDArchEntries <|> getGNUArchEntries Nothing++putBSDArch :: Archive -> PutM ()+putBSDArch (Archive as) = do+ putArchMagic+ mapM_ putArchEntry (processEntries as)++ where+ padStr pad size str = take size $ str <> repeat pad+ nameSize name = case length name `divMod` 4 of+ (n, 0) -> 4 * n+ (n, _) -> 4 * (n + 1)+ needExt name = length name > 16 || ' ' `elem` name+ processEntry :: ArchiveEntry -> ArchiveEntry+ processEntry archive@(ArchiveEntry name _ _ _ _ st_size _)+ | needExt name = archive { filename = "#1/" <> show sz+ , filedata = C.pack (padStr '\0' sz name) <> filedata archive+ , filesize = st_size + sz }+ | otherwise = archive++ where sz = nameSize name++ processEntries = map processEntry++putGNUArch :: Archive -> PutM ()+putGNUArch (Archive as) = do+ putArchMagic+ mapM_ putArchEntry (processEntries as)++ where+ processEntry :: ArchiveEntry -> ArchiveEntry -> (ArchiveEntry, ArchiveEntry)+ processEntry extInfo archive@(ArchiveEntry name _ _ _ _ _ _)+ | length name > 15 = ( extInfo { filesize = filesize extInfo + length name + 2+ , filedata = filedata extInfo <> C.pack name <> "/\n" }+ , archive { filename = "/" <> show (filesize extInfo) } )+ | otherwise = ( extInfo, archive { filename = name <> "/" } )++ processEntries :: [ArchiveEntry] -> [ArchiveEntry]+ processEntries =+ uncurry (:) . mapAccumL processEntry (ArchiveEntry "//" 0 0 0 0 0 mempty)++parseAr :: B.ByteString -> Archive+parseAr = runGet getArch . L.fromChunks . pure++writeBSDAr, writeGNUAr :: FilePath -> Archive -> IO ()+writeBSDAr fp = L.writeFile fp . runPut . putBSDArch+writeGNUAr fp = L.writeFile fp . runPut . putGNUArch++loadAr :: FilePath -> IO Archive+loadAr fp = parseAr <$> B.readFile fp++loadObj :: FilePath -> IO ArchiveEntry+loadObj fp = do+ payload <- B.readFile fp+ (modt, own, grp, mode) <- fileInfo fp+ return $ ArchiveEntry+ (takeFileName fp) modt own grp mode+ (B.length payload) payload++-- | Take a filePath and return (mod time, own, grp, mode in decimal)+fileInfo :: FilePath -> IO ( Int, Int, Int, Int) -- ^ mod time, own, grp, mode (in decimal)+#if defined(mingw32_HOST_OS)+-- on windows mod time, owner group and mode are zero.+fileInfo _ = pure (0,0,0,0)+#else+fileInfo fp = go <$> POSIX.getFileStatus fp+ where go status = ( fromEnum $ POSIX.modificationTime status+ , fromIntegral $ POSIX.fileOwner status+ , fromIntegral $ POSIX.fileGroup status+ , oct2dec . fromIntegral $ POSIX.fileMode status+ )++oct2dec :: Int -> Int+oct2dec = foldl (\a b -> a * 10 + b) 0 . reverse . dec 8+ where dec _ 0 = []+ dec b i = let (rest, last) = i `quotRem` b+ in last:dec b rest++#endif
main/CmdLineParser.hs view
@@ -17,16 +17,22 @@ Flag(..), defFlag, defGhcFlag, defGhciFlag, defHiddenFlag, errorsToGhcException, - EwM, runEwM, addErr, addWarn, getArg, getCurLoc, liftEwM, deprecate+ Err(..), Warn(..), WarnReason(..),++ EwM, runEwM, addErr, addWarn, addFlagWarn, getArg, getCurLoc, liftEwM,+ deprecate ) where #include "HsVersions.h" +import GhcPrelude+ import Util import Outputable import Panic import Bag import SrcLoc+import Json import Data.Function import Data.List@@ -81,8 +87,30 @@ -- The EwM monad -------------------------------------------------------- -type Err = Located String-type Warn = Located String+-- | Used when filtering warnings: if a reason is given+-- it can be filtered out when displaying.+data WarnReason+ = NoReason+ | ReasonDeprecatedFlag+ | ReasonUnrecognisedFlag+ deriving (Eq, Show)++instance Outputable WarnReason where+ ppr = text . show++instance ToJson WarnReason where+ json NoReason = JSNull+ json reason = JSString $ show reason++-- | A command-line error message+newtype Err = Err { errMsg :: Located String }++-- | A command-line warning message and the reason it arose+data Warn = Warn+ { warnReason :: WarnReason,+ warnMsg :: Located String+ }+ type Errs = Bag Err type Warns = Bag Warn @@ -110,15 +138,19 @@ setArg l (EwM f) = EwM (\_ es ws -> f l es ws) addErr :: Monad m => String -> EwM m ()-addErr e = EwM (\(L loc _) es ws -> return (es `snocBag` L loc e, ws, ()))+addErr e = EwM (\(L loc _) es ws -> return (es `snocBag` Err (L loc e), ws, ())) addWarn :: Monad m => String -> EwM m ()-addWarn msg = EwM (\(L loc _) es ws -> return (es, ws `snocBag` L loc msg, ()))+addWarn = addFlagWarn NoReason +addFlagWarn :: Monad m => WarnReason -> String -> EwM m ()+addFlagWarn reason msg = EwM $+ (\(L loc _) es ws -> return (es, ws `snocBag` Warn reason (L loc msg), ()))+ deprecate :: Monad m => String -> EwM m () deprecate s = do arg <- getArg- addWarn (arg ++ " is deprecated: " ++ s)+ addFlagWarn ReasonDeprecatedFlag (arg ++ " is deprecated: " ++ s) getArg :: Monad m => EwM m String getArg = EwM (\(L _ arg) es ws -> return (es, ws, arg))@@ -164,8 +196,8 @@ => [Flag m] -- cmdline parser spec -> [Located String] -- args -> m ( [Located String], -- spare args- [Located String], -- errors- [Located String] ) -- warnings+ [Err], -- errors+ [Warn] ) -- warnings processArgs spec args = do (errs, warns, spare) <- runEwM action return (spare, bagToList errs, bagToList warns)
main/CodeOutput.hs view
@@ -10,6 +10,8 @@ #include "HsVersions.h" +import GhcPrelude+ import AsmCodeGen ( nativeCodeGen ) import LlvmCodeGen ( llvmCodeGen ) @@ -23,9 +25,9 @@ import HscTypes import DynFlags import Config-import SysTools import Stream (Stream) import qualified Stream+import FileCleanup import ErrUtils import Outputable@@ -202,7 +204,7 @@ outputForeignStubs dflags mod location stubs = do let stub_h = mkStubPaths dflags (moduleName mod) location- stub_c <- newTempName dflags "c"+ stub_c <- newTempName dflags TFL_CurrentModule "c" case stubs of NoStubs ->@@ -276,6 +278,6 @@ LangCxx -> return "cpp" LangObjc -> return "m" LangObjcxx -> return "mm"- fp <- newTempName dflags extension+ fp <- newTempName dflags TFL_CurrentModule extension writeFile fp file_contents return fp
main/Constants.hs view
@@ -6,6 +6,8 @@ module Constants (module Constants) where +import GhcPrelude+ import Config hiVersion :: Integer@@ -35,6 +37,10 @@ wORD64_SIZE :: Int wORD64_SIZE = 8++-- Size of float in bytes.+fLOAT_SIZE :: Int+fLOAT_SIZE = 4 tARGET_MAX_CHAR :: Int tARGET_MAX_CHAR = 0x10ffff
main/DriverMkDepend.hs view
@@ -14,12 +14,13 @@ #include "HsVersions.h" +import GhcPrelude+ import qualified GHC import GhcMonad import DynFlags import Util import HscTypes-import SysTools ( newTempName ) import qualified SysTools import Module import Digraph ( SCC(..) )@@ -29,6 +30,7 @@ import SrcLoc import Data.List import FastString+import FileCleanup import Exception import ErrUtils@@ -74,11 +76,11 @@ targets <- mapM (\s -> GHC.guessTarget s Nothing) srcs GHC.setTargets targets let excl_mods = depExcludeMods dflags- mod_summaries <- GHC.depanal excl_mods True {- Allow dup roots -}+ module_graph <- GHC.depanal excl_mods True {- Allow dup roots -} -- Sort into dependency order -- There should be no cycles- let sorted = GHC.topSortModuleGraph False mod_summaries Nothing+ let sorted = GHC.topSortModuleGraph False module_graph Nothing -- Print out the dependencies if wanted liftIO $ debugTraceMsg dflags 2 (text "Module dependencies" $$ ppr sorted)@@ -90,7 +92,7 @@ mapM_ (liftIO . processDeps dflags hsc_env excl_mods root (mkd_tmp_hdl files)) sorted -- If -ddump-mod-cycles, show cycles in the module graph- liftIO $ dumpModCycles dflags mod_summaries+ liftIO $ dumpModCycles dflags module_graph -- Tidy up liftIO $ endMkDependHS dflags files@@ -121,7 +123,7 @@ beginMkDependHS dflags = do -- open a new temp file in which to stuff the dependency info -- as we go along.- tmp_file <- newTempName dflags "dep"+ tmp_file <- newTempName dflags TFL_CurrentModule "dep" tmp_hdl <- openFile tmp_file WriteMode -- open the makefile@@ -337,8 +339,8 @@ -- Module cycles ----------------------------------------------------------------- -dumpModCycles :: DynFlags -> [ModSummary] -> IO ()-dumpModCycles dflags mod_summaries+dumpModCycles :: DynFlags -> ModuleGraph -> IO ()+dumpModCycles dflags module_graph | not (dopt Opt_D_dump_mod_cycles dflags) = return () @@ -350,7 +352,8 @@ where cycles :: [[ModSummary]]- cycles = [ c | CyclicSCC c <- GHC.topSortModuleGraph True mod_summaries Nothing ]+ cycles =+ [ c | CyclicSCC c <- GHC.topSortModuleGraph True module_graph Nothing ] pp_cycles = vcat [ (text "---------- Cycle" <+> int n <+> ptext (sLit "----------")) $$ pprCycle c $$ blankLine@@ -378,7 +381,8 @@ loop_breaker = head boot_only all_others = tail boot_only ++ others- groups = GHC.topSortModuleGraph True all_others Nothing+ groups =+ GHC.topSortModuleGraph True (mkModuleGraph all_others) Nothing pp_ms summary = text mod_str <> text (take (20 - length mod_str) (repeat ' ')) <+> (pp_imps empty (map snd (ms_imps summary)) $$
main/DriverPhases.hs view
@@ -40,6 +40,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} DynFlags import Outputable import Platform
main/DriverPipeline.hs view
@@ -28,19 +28,20 @@ phaseOutputFilename, getOutputFilename, getPipeState, getPipeEnv, hscPostBackendPhase, getLocation, setModLocation, setDynFlags, runPhase, exeFileName,- mkExtraObjToLinkIntoBinary, mkNoteObjsToLinkIntoBinary, maybeCreateManifest, linkingNeeded, checkLinkInfo, writeInterfaceOnlyMode ) where #include "HsVersions.h" +import GhcPrelude+ import PipelineMonad import Packages import HeaderInfo import DriverPhases import SysTools-import Elf+import SysTools.ExtraObj import HscMain import Finder import HscTypes hiding ( Hsc )@@ -61,13 +62,15 @@ import TcRnTypes import Hooks import qualified GHC.LanguageExtensions as LangExt+import FileCleanup+import Ar import Exception import System.Directory import System.FilePath import System.IO import Control.Monad-import Data.List ( isSuffixOf )+import Data.List ( isSuffixOf, intercalate ) import Data.Maybe import Data.Version @@ -86,7 +89,12 @@ preprocess hsc_env (filename, mb_phase) = ASSERT2(isJust mb_phase || isHaskellSrcFilename filename, text filename) runPipeline anyHsc hsc_env (filename, fmap RealPhase mb_phase)- Nothing Temporary Nothing{-no ModLocation-} []{-no foreign objects-}+ Nothing+ -- We keep the processed file for the whole session to save on+ -- duplicated work in ghci.+ (Temporary TFL_GhcSession)+ Nothing{-no ModLocation-}+ []{-no foreign objects-} -- --------------------------------------------------------------------------- @@ -138,9 +146,11 @@ let flags = hsc_dflags hsc_env0 in do unless (gopt Opt_KeepHiFiles flags) $- addFilesToClean flags [ml_hi_file $ ms_location summary]+ addFilesToClean flags TFL_CurrentModule $+ [ml_hi_file $ ms_location summary] unless (gopt Opt_KeepOFiles flags) $- addFilesToClean flags [ml_obj_file $ ms_location summary]+ addFilesToClean flags TFL_GhcSession $+ [ml_obj_file $ ms_location summary] case (status, hsc_lang) of (HscUpToDate, _) ->@@ -165,7 +175,8 @@ in return hmi0 { hm_linkable = Just linkable } (HscUpdateSig, _) -> do output_fn <- getOutputFilename next_phase- Temporary basename dflags next_phase (Just location)+ (Temporary TFL_CurrentModule) basename dflags+ next_phase (Just location) -- #10660: Use the pipeline instead of calling -- compileEmptyStub directly, so -dynamic-too gets@@ -204,7 +215,8 @@ return hmi0 { hm_linkable = Just linkable } (HscRecomp cgguts summary, _) -> do output_fn <- getOutputFilename next_phase- Temporary basename dflags next_phase (Just location)+ (Temporary TFL_CurrentModule)+ basename dflags next_phase (Just location) -- We're in --make mode: finish the compilation pipeline. _ <- runPipeline StopLn hsc_env (output_fn,@@ -225,9 +237,7 @@ input_fn = expectJust "compile:hs" (ml_hs_file location) input_fnpp = ms_hspp_file summary mod_graph = hsc_mod_graph hsc_env0- needsTH = any (xopt LangExt.TemplateHaskell . ms_hspp_opts) mod_graph- needsQQ = any (xopt LangExt.QuasiQuotes . ms_hspp_opts) mod_graph- needsLinker = needsTH || needsQQ+ needsLinker = needsTemplateHaskellOrQQ mod_graph isDynWay = any (== WayDyn) (ways dflags0) isProfWay = any (== WayProf) (ways dflags0) internalInterpreter = not (gopt Opt_ExternalInterpreter dflags0)@@ -240,8 +250,8 @@ -- #8180 - when using TemplateHaskell, switch on -dynamic-too so -- the linker can correctly load the object files. This isn't necessary -- when using -fexternal-interpreter.- dflags1 = if needsLinker && dynamicGhc && internalInterpreter &&- not isDynWay && not isProfWay+ dflags1 = if dynamicGhc && internalInterpreter &&+ not isDynWay && not isProfWay && needsLinker then gopt_set dflags0 Opt_BuildDynamicToo else dflags0 @@ -299,8 +309,9 @@ LangObjcxx -> Cobjcxx (_, stub_o) <- runPipeline StopLn hsc_env (stub_c, Just (RealPhase phase))- Nothing Temporary Nothing{-no ModLocation-} []-+ Nothing (Temporary TFL_GhcSession)+ Nothing{-no ModLocation-}+ [] return stub_o compileStub :: HscEnv -> FilePath -> IO FilePath@@ -315,7 +326,7 @@ -- so that ranlib on OS X doesn't complain, see -- http://ghc.haskell.org/trac/ghc/ticket/12673 -- and https://github.com/haskell/cabal/issues/2257- empty_stub <- newTempName dflags "c"+ empty_stub <- newTempName dflags TFL_CurrentModule "c" let src = text "int" <+> ppr (mkModule (thisPackage dflags) mod_name) <+> text "= 0;" writeFile empty_stub (showSDoc dflags (pprCode CStyle src)) _ <- runPipeline StopLn hsc_env@@ -378,7 +389,7 @@ let staticLink = case ghcLink dflags of LinkStaticLib -> True- _ -> platformBinariesAreStaticLibs (targetPlatform dflags)+ _ -> False home_mod_infos = eltsHpt hpt @@ -413,7 +424,7 @@ -- Don't showPass in Batch mode; doLink will do that for us. let link = case ghcLink dflags of LinkBinary -> linkBinary- LinkStaticLib -> linkStaticLibCheck+ LinkStaticLib -> linkStaticLib LinkDynLib -> linkDynLibCheck other -> panicBadLink other link dflags obj_files pkg_deps@@ -463,50 +474,11 @@ then return True else checkLinkInfo dflags pkg_deps exe_file --- Returns 'False' if it was, and we can avoid linking, because the--- previous binary was linked with "the same options".-checkLinkInfo :: DynFlags -> [InstalledUnitId] -> FilePath -> IO Bool-checkLinkInfo dflags pkg_deps exe_file- | not (platformSupportsSavingLinkOpts (platformOS (targetPlatform dflags)))- -- ToDo: Windows and OS X do not use the ELF binary format, so- -- readelf does not work there. We need to find another way to do- -- this.- = return False -- conservatively we should return True, but not- -- linking in this case was the behaviour for a long- -- time so we leave it as-is.- | otherwise- = do- link_info <- getLinkInfo dflags pkg_deps- debugTraceMsg dflags 3 $ text ("Link info: " ++ link_info)- m_exe_link_info <- readElfNoteAsString dflags exe_file- ghcLinkInfoSectionName ghcLinkInfoNoteName- let sameLinkInfo = (Just link_info == m_exe_link_info)- debugTraceMsg dflags 3 $ case m_exe_link_info of- Nothing -> text "Exe link info: Not found"- Just s- | sameLinkInfo -> text ("Exe link info is the same")- | otherwise -> text ("Exe link info is different: " ++ s)- return (not sameLinkInfo)--platformSupportsSavingLinkOpts :: OS -> Bool-platformSupportsSavingLinkOpts os- | os == OSSolaris2 = False -- see #5382- | otherwise = osElfTarget os---- See Note [LinkInfo section]-ghcLinkInfoSectionName :: String-ghcLinkInfoSectionName = ".debug-ghc-link-info"- -- if we use the ".debug" prefix, then strip will strip it by default---- Identifier for the note (see Note [LinkInfo section])-ghcLinkInfoNoteName :: String-ghcLinkInfoNoteName = "GHC link info"- findHSLib :: DynFlags -> [String] -> String -> IO (Maybe FilePath) findHSLib dflags dirs lib = do let batch_lib_file = if WayDyn `notElem` ways dflags- then "lib" ++ lib <.> "a"- else mkSOName (targetPlatform dflags) lib+ then "lib" ++ lib <.> "a"+ else mkSOName (targetPlatform dflags) lib found <- filterM doesFileExist (map (</> batch_lib_file) dirs) case found of [] -> return Nothing@@ -535,10 +507,10 @@ -- When linking, the -o argument refers to the linker's output. -- otherwise, we use it as the name for the pipeline's output. output- -- If we are dong -fno-code, then act as if the output is+ -- If we are doing -fno-code, then act as if the output is -- 'Temporary'. This stops GHC trying to copy files to their -- final location.- | HscNothing <- hscTarget dflags = Temporary+ | HscNothing <- hscTarget dflags = Temporary TFL_CurrentModule | StopLn <- stop_phase, not (isNoLink ghc_link) = Persistent -- -o foo applies to linker | isJust mb_o_file = SpecificFile@@ -564,7 +536,7 @@ = case ghcLink dflags of NoLink -> return () LinkBinary -> linkBinary dflags o_files []- LinkStaticLib -> linkStaticLibCheck dflags o_files []+ LinkStaticLib -> linkStaticLib dflags o_files [] LinkDynLib -> linkDynLibCheck dflags o_files [] other -> panicBadLink other @@ -696,7 +668,7 @@ -- copy the file, remembering to prepend a {-# LINE #-} pragma so that -- further compilation stages can tell what the original filename was. case output_spec env of- Temporary ->+ Temporary _ -> return (dflags, input_fn) output -> do pst <- getPipeState@@ -780,7 +752,9 @@ Nothing -> panic "SpecificFile: No filename" | keep_this_output = persistent_fn- | otherwise = newTempName dflags suffix+ | Temporary lifetime <- output = newTempName dflags lifetime suffix+ | otherwise = newTempName dflags TFL_CurrentModule+ suffix where hcsuf = hcSuf dflags odir = objectDir dflags@@ -818,6 +792,65 @@ | Just d <- odir = d </> persistent | otherwise = persistent ++-- | The fast LLVM Pipeline skips the mangler and assembler,+-- emitting object code directly from llc.+--+-- slow: opt -> llc -> .s -> mangler -> as -> .o+-- fast: opt -> llc -> .o+--+-- hidden flag: -ffast-llvm+--+-- if keep-s-files is specified, we need to go through+-- the slow pipeline (Kavon Farvardin requested this).+fastLlvmPipeline :: DynFlags -> Bool+fastLlvmPipeline dflags+ = not (gopt Opt_KeepSFiles dflags) && gopt Opt_FastLlvm dflags++-- | LLVM Options. These are flags to be passed to opt and llc, to ensure+-- consistency we list them in pairs, so that they form groups.+llvmOptions :: DynFlags+ -> [(String, String)] -- ^ pairs of (opt, llc) arguments+llvmOptions dflags =+ [("-enable-tbaa -tbaa", "-enable-tbaa") | gopt Opt_LlvmTBAA dflags ]+ ++ [("-relocation-model=" ++ rmodel+ ,"-relocation-model=" ++ rmodel) | not (null rmodel)]+ ++ [("-stack-alignment=" ++ (show align)+ ,"-stack-alignment=" ++ (show align)) | align > 0 ]+ ++ [("", "-filetype=obj") | fastLlvmPipeline dflags ]++ -- Additional llc flags+ ++ [("", "-mcpu=" ++ mcpu) | not (null mcpu) ]+ ++ [("", "-mattr=" ++ attrs) | not (null attrs) ]++ where target = LLVM_TARGET+ Just (LlvmTarget _ mcpu mattr) = lookup target (llvmTargets dflags)++ -- Relocation models+ rmodel | gopt Opt_PIC dflags = "pic"+ | positionIndependent dflags = "pic"+ | WayDyn `elem` ways dflags = "dynamic-no-pic"+ | otherwise = "static"++ align :: Int+ align = case platformArch (targetPlatform dflags) of+ ArchX86_64 | isAvxEnabled dflags -> 32+ _ -> 0++ attrs :: String+ attrs = intercalate "," $ mattr+ ++ ["+sse42" | isSse4_2Enabled dflags ]+ ++ ["+sse2" | isSse2Enabled dflags ]+ ++ ["+sse" | isSseEnabled dflags ]+ ++ ["+avx512f" | isAvx512fEnabled dflags ]+ ++ ["+avx2" | isAvx2Enabled dflags ]+ ++ ["+avx" | isAvxEnabled dflags ]+ ++ ["+avx512cd"| isAvx512cdEnabled dflags ]+ ++ ["+avx512er"| isAvx512erEnabled dflags ]+ ++ ["+avx512pf"| isAvx512pfEnabled dflags ]+ ++ ["+bmi" | isBmiEnabled dflags ]+ ++ ["+bmi2" | isBmi2Enabled dflags ]+ -- ----------------------------------------------------------------------------- -- | Each phase in the pipeline returns the next phase to execute, and the -- name of the file in which the output was placed.@@ -1148,10 +1181,6 @@ (cmdlineFrameworkPaths ++ pkgFrameworkPaths) else return [] - let split_objs = gopt Opt_SplitObjs dflags- split_opt | hcc && split_objs = [ "-DUSE_SPLIT_MARKERS" ]- | otherwise = [ ]- let cc_opt | optLevel dflags >= 2 = [ "-O2" ] | optLevel dflags >= 1 = [ "-O" ] | otherwise = []@@ -1230,7 +1259,6 @@ ++ cc_opt ++ [ "-include", ghcVersionH ] ++ framework_paths- ++ split_opt ++ include_paths ++ pkg_extra_cc_opts ))@@ -1243,7 +1271,8 @@ runPhase (RealPhase Splitter) input_fn dflags = do -- tmp_pfx is the prefix used for the split .s files - split_s_prefix <- liftIO $ SysTools.newTempName dflags "split"+ split_s_prefix <-+ liftIO $ newTempName dflags TFL_CurrentModule "split" let n_files_fn = split_s_prefix liftIO $ SysTools.runSplit dflags@@ -1260,7 +1289,7 @@ setDynFlags dflags' -- Remember to delete all these files- liftIO $ addFilesToClean dflags'+ liftIO $ addFilesToClean dflags' TFL_CurrentModule $ [ split_s_prefix ++ "__" ++ show n ++ ".s" | n <- [1..n_files]] @@ -1406,7 +1435,7 @@ if null foreign_os then return () else liftIO $ do- tmp_split_1 <- newTempName dflags osuf+ tmp_split_1 <- newTempName dflags TFL_CurrentModule osuf let split_1 = split_obj 1 copyFile split_1 tmp_split_1 removeFile split_1@@ -1419,122 +1448,116 @@ ----------------------------------------------------------------------------- -- LlvmOpt phase- runPhase (RealPhase LlvmOpt) input_fn dflags = do- let opt_lvl = max 0 (min 2 $ optLevel dflags)- -- don't specify anything if user has specified commands. We do this- -- for opt but not llc since opt is very specifically for optimisation- -- passes only, so if the user is passing us extra options we assume- -- they know what they are doing and don't get in the way.- optFlag = if null (getOpts dflags opt_lo)- then map SysTools.Option $ words (llvmOpts !! opt_lvl)- else []- tbaa | gopt Opt_LlvmTBAA dflags = "--enable-tbaa=true"- | otherwise = "--enable-tbaa=false"-- output_fn <- phaseOutputFilename LlvmLlc liftIO $ SysTools.runLlvmOpt dflags- ([ SysTools.FileOption "" input_fn,- SysTools.Option "-o",- SysTools.FileOption "" output_fn]- ++ optFlag- ++ [SysTools.Option tbaa])+ ( optFlag+ ++ defaultOptions +++ [ SysTools.FileOption "" input_fn+ , SysTools.Option "-o"+ , SysTools.FileOption "" output_fn]+ ) return (RealPhase LlvmLlc, output_fn) where -- we always (unless -optlo specified) run Opt since we rely on it to -- fix up some pretty big deficiencies in the code we generate- llvmOpts = [ "-mem2reg -globalopt"- , "-O1 -globalopt"- , "-O2"- ]+ llvmOpts = case optLevel dflags of+ 0 -> "-mem2reg -globalopt"+ 1 -> "-O1 -globalopt"+ _ -> "-O2" + -- don't specify anything if user has specified commands. We do this+ -- for opt but not llc since opt is very specifically for optimisation+ -- passes only, so if the user is passing us extra options we assume+ -- they know what they are doing and don't get in the way.+ optFlag = if null (getOpts dflags opt_lo)+ then map SysTools.Option $ words llvmOpts+ else []++ defaultOptions = map SysTools.Option . concat . fmap words . fst+ $ unzip (llvmOptions dflags)+ ----------------------------------------------------------------------------- -- LlvmLlc phase runPhase (RealPhase LlvmLlc) input_fn dflags = do- let opt_lvl = max 0 (min 2 $ optLevel dflags)- -- iOS requires external references to be loaded indirectly from the- -- DATA segment or dyld traps at runtime writing into TEXT: see #7722- rmodel | platformOS (targetPlatform dflags) == OSiOS = "dynamic-no-pic"- | positionIndependent dflags = "pic"- | WayDyn `elem` ways dflags = "dynamic-no-pic"- | otherwise = "static"- tbaa | gopt Opt_LlvmTBAA dflags = "--enable-tbaa=true"- | otherwise = "--enable-tbaa=false"-- -- hidden debugging flag '-dno-llvm-mangler' to skip mangling- let next_phase = case gopt Opt_NoLlvmMangler dflags of- False -> LlvmMangle- True | gopt Opt_SplitObjs dflags -> Splitter- True -> As False+ next_phase <- if fastLlvmPipeline dflags+ then maybeMergeForeign+ -- hidden debugging flag '-dno-llvm-mangler' to skip mangling+ else case gopt Opt_NoLlvmMangler dflags of+ False -> return LlvmMangle+ True | gopt Opt_SplitObjs dflags -> return Splitter+ True -> return (As False) output_fn <- phaseOutputFilename next_phase liftIO $ SysTools.runLlvmLlc dflags- ([ SysTools.Option (llvmOpts !! opt_lvl),- SysTools.Option $ "-relocation-model=" ++ rmodel,- SysTools.FileOption "" input_fn,- SysTools.Option "-o", SysTools.FileOption "" output_fn]- ++ [SysTools.Option tbaa]- ++ map SysTools.Option fpOpts- ++ map SysTools.Option abiOpts- ++ map SysTools.Option sseOpts- ++ map SysTools.Option avxOpts- ++ map SysTools.Option avx512Opts- ++ map SysTools.Option stackAlignOpts)+ ( optFlag+ ++ defaultOptions+ ++ [ SysTools.FileOption "" input_fn+ , SysTools.Option "-o"+ , SysTools.FileOption "" output_fn+ ]+ ) return (RealPhase next_phase, output_fn) where- -- Bug in LLVM at O3 on OSX.- llvmOpts = if platformOS (targetPlatform dflags) == OSDarwin- then ["-O1", "-O2", "-O2"]- else ["-O1", "-O2", "-O3"]- -- On ARMv7 using LLVM, LLVM fails to allocate floating point registers- -- while compiling GHC source code. It's probably due to fact that it- -- does not enable VFP by default. Let's do this manually here- fpOpts = case platformArch (targetPlatform dflags) of- ArchARM ARMv7 ext _ -> if (elem VFPv3 ext)- then ["-mattr=+v7,+vfp3"]- else if (elem VFPv3D16 ext)- then ["-mattr=+v7,+vfp3,+d16"]- else []- ArchARM ARMv6 ext _ -> if (elem VFPv2 ext)- then ["-mattr=+v6,+vfp2"]- else ["-mattr=+v6"]- _ -> []- -- On Ubuntu/Debian with ARM hard float ABI, LLVM's llc still- -- compiles into soft-float ABI. We need to explicitly set abi- -- to hard- abiOpts = case platformArch (targetPlatform dflags) of- ArchARM _ _ HARD -> ["-float-abi=hard"]- ArchARM _ _ _ -> []- _ -> []+ -- Note [Clamping of llc optimizations]+ --+ -- See #13724+ --+ -- we clamp the llc optimization between [1,2]. This is because passing -O0+ -- to llc 3.9 or llc 4.0, the naive register allocator can fail with+ --+ -- Error while trying to spill R1 from class GPR: Cannot scavenge register+ -- without an emergency spill slot!+ --+ -- Observed at least with target 'arm-unknown-linux-gnueabihf'.+ --+ --+ -- With LLVM4, llc -O3 crashes when ghc-stage1 tries to compile+ -- rts/HeapStackCheck.cmm+ --+ -- llc -O3 '-mtriple=arm-unknown-linux-gnueabihf' -enable-tbaa /var/folders/fv/xqjrpfj516n5xq_m_ljpsjx00000gn/T/ghc33674_0/ghc_6.bc -o /var/folders/fv/xqjrpfj516n5xq_m_ljpsjx00000gn/T/ghc33674_0/ghc_7.lm_s+ -- 0 llc 0x0000000102ae63e8 llvm::sys::PrintStackTrace(llvm::raw_ostream&) + 40+ -- 1 llc 0x0000000102ae69a6 SignalHandler(int) + 358+ -- 2 libsystem_platform.dylib 0x00007fffc23f4b3a _sigtramp + 26+ -- 3 libsystem_c.dylib 0x00007fffc226498b __vfprintf + 17876+ -- 4 llc 0x00000001029d5123 llvm::SelectionDAGISel::LowerArguments(llvm::Function const&) + 5699+ -- 5 llc 0x0000000102a21a35 llvm::SelectionDAGISel::SelectAllBasicBlocks(llvm::Function const&) + 3381+ -- 6 llc 0x0000000102a202b1 llvm::SelectionDAGISel::runOnMachineFunction(llvm::MachineFunction&) + 1457+ -- 7 llc 0x0000000101bdc474 (anonymous namespace)::ARMDAGToDAGISel::runOnMachineFunction(llvm::MachineFunction&) + 20+ -- 8 llc 0x00000001025573a6 llvm::MachineFunctionPass::runOnFunction(llvm::Function&) + 134+ -- 9 llc 0x000000010274fb12 llvm::FPPassManager::runOnFunction(llvm::Function&) + 498+ -- 10 llc 0x000000010274fd23 llvm::FPPassManager::runOnModule(llvm::Module&) + 67+ -- 11 llc 0x00000001027501b8 llvm::legacy::PassManagerImpl::run(llvm::Module&) + 920+ -- 12 llc 0x000000010195f075 compileModule(char**, llvm::LLVMContext&) + 12133+ -- 13 llc 0x000000010195bf0b main + 491+ -- 14 libdyld.dylib 0x00007fffc21e5235 start + 1+ -- Stack dump:+ -- 0. Program arguments: llc -O3 -mtriple=arm-unknown-linux-gnueabihf -enable-tbaa /var/folders/fv/xqjrpfj516n5xq_m_ljpsjx00000gn/T/ghc33674_0/ghc_6.bc -o /var/folders/fv/xqjrpfj516n5xq_m_ljpsjx00000gn/T/ghc33674_0/ghc_7.lm_s+ -- 1. Running pass 'Function Pass Manager' on module '/var/folders/fv/xqjrpfj516n5xq_m_ljpsjx00000gn/T/ghc33674_0/ghc_6.bc'.+ -- 2. Running pass 'ARM Instruction Selection' on function '@"stg_gc_f1$def"'+ --+ -- Observed at least with -mtriple=arm-unknown-linux-gnueabihf -enable-tbaa+ --+ llvmOpts = case optLevel dflags of+ 0 -> "-O1" -- required to get the non-naive reg allocator. Passing -regalloc=greedy is not sufficient.+ 1 -> "-O1"+ _ -> "-O2" - sseOpts | isSse4_2Enabled dflags = ["-mattr=+sse42"]- | isSse2Enabled dflags = ["-mattr=+sse2"]- | isSseEnabled dflags = ["-mattr=+sse"]- | otherwise = []+ optFlag = if null (getOpts dflags opt_lc)+ then map SysTools.Option $ words llvmOpts+ else [] - avxOpts | isAvx512fEnabled dflags = ["-mattr=+avx512f"]- | isAvx2Enabled dflags = ["-mattr=+avx2"]- | isAvxEnabled dflags = ["-mattr=+avx"]- | otherwise = []+ defaultOptions = map SysTools.Option . concat . fmap words . snd+ $ unzip (llvmOptions dflags) - avx512Opts =- [ "-mattr=+avx512cd" | isAvx512cdEnabled dflags ] ++- [ "-mattr=+avx512er" | isAvx512erEnabled dflags ] ++- [ "-mattr=+avx512pf" | isAvx512pfEnabled dflags ] - stackAlignOpts =- case platformArch (targetPlatform dflags) of- ArchX86_64 | isAvxEnabled dflags -> ["-stack-alignment=32"]- _ -> []- ----------------------------------------------------------------------------- -- LlvmMangle phase @@ -1575,175 +1598,46 @@ PipeEnv{ src_basename=basename, src_suffix=suff } <- getPipeEnv-- -- Build a ModLocation to pass to hscMain.- -- The source filename is rather irrelevant by now, but it's used- -- by hscMain for messages. hscMain also needs- -- the .hi and .o filenames, and this is as good a way- -- as any to generate them, and better than most. (e.g. takes- -- into account the -osuf flags)- location1 <- liftIO $ mkHomeModLocation2 dflags mod_name basename suff-- -- Boot-ify it if necessary- let location2 | HsBootFile <- src_flavour = addBootSuffixLocn location1- | otherwise = location1--- -- Take -ohi into account if present- -- This can't be done in mkHomeModuleLocation because- -- it only applies to the module being compiles- let ohi = outputHi dflags- location3 | Just fn <- ohi = location2{ ml_hi_file = fn }- | otherwise = location2-- -- Take -o into account if present- -- Very like -ohi, but we must *only* do this if we aren't linking- -- (If we're linking then the -o applies to the linked thing, not to- -- the object file for one module.)- -- Note the nasty duplication with the same computation in compileFile above- let expl_o_file = outputFile dflags- location4 | Just ofile <- expl_o_file- , isNoLink (ghcLink dflags)- = location3 { ml_obj_file = ofile }- | otherwise = location3-- return location4--mkExtraObj :: DynFlags -> Suffix -> String -> IO FilePath-mkExtraObj dflags extn xs- = do cFile <- newTempName dflags extn- oFile <- newTempName dflags "o"- writeFile cFile xs- ccInfo <- liftIO $ getCompilerInfo dflags- SysTools.runCc dflags- ([Option "-c",- FileOption "" cFile,- Option "-o",- FileOption "" oFile]- ++ if extn /= "s"- then cOpts- else asmOpts ccInfo)- return oFile- where- -- Pass a different set of options to the C compiler depending one whether- -- we're compiling C or assembler. When compiling C, we pass the usual- -- set of include directories and PIC flags.- cOpts = map Option (picCCOpts dflags)- ++ map (FileOption "-I")- (includeDirs $ getPackageDetails dflags rtsUnitId)-- -- When compiling assembler code, we drop the usual C options, and if the- -- compiler is Clang, we add an extra argument to tell Clang to ignore- -- unused command line options. See trac #11684.- asmOpts ccInfo =- if any (ccInfo ==) [Clang, AppleClang, AppleClang51]- then [Option "-Qunused-arguments"]- else []----- When linking a binary, we need to create a C main() function that--- starts everything off. This used to be compiled statically as part--- of the RTS, but that made it hard to change the -rtsopts setting,--- so now we generate and compile a main() stub as part of every--- binary and pass the -rtsopts setting directly to the RTS (#5373)----mkExtraObjToLinkIntoBinary :: DynFlags -> IO FilePath-mkExtraObjToLinkIntoBinary dflags = do- when (gopt Opt_NoHsMain dflags && haveRtsOptsFlags dflags) $ do- putLogMsg dflags NoReason SevInfo noSrcSpan- (defaultUserStyle dflags)- (text "Warning: -rtsopts and -with-rtsopts have no effect with -no-hs-main." $$- text " Call hs_init_ghc() from your main() function to set these options.")-- mkExtraObj dflags "c" (showSDoc dflags main)-- where- main- | gopt Opt_NoHsMain dflags = Outputable.empty- | otherwise = vcat [- text "#include \"Rts.h\"",- text "extern StgClosure ZCMain_main_closure;",- text "int main(int argc, char *argv[])",- char '{',- text " RtsConfig __conf = defaultRtsConfig;",- text " __conf.rts_opts_enabled = "- <> text (show (rtsOptsEnabled dflags)) <> semi,- text " __conf.rts_opts_suggestions = "- <> text (if rtsOptsSuggestions dflags- then "true"- else "false") <> semi,- case rtsOpts dflags of- Nothing -> Outputable.empty- Just opts -> text " __conf.rts_opts= " <>- text (show opts) <> semi,- text " __conf.rts_hs_main = true;",- text " return hs_main(argc,argv,&ZCMain_main_closure,__conf);",- char '}',- char '\n' -- final newline, to keep gcc happy- ]---- Write out the link info section into a new assembly file. Previously--- this was included as inline assembly in the main.c file but this--- is pretty fragile. gas gets upset trying to calculate relative offsets--- that span the .note section (notably .text) when debug info is present-mkNoteObjsToLinkIntoBinary :: DynFlags -> [InstalledUnitId] -> IO [FilePath]-mkNoteObjsToLinkIntoBinary dflags dep_packages = do- link_info <- getLinkInfo dflags dep_packages-- if (platformSupportsSavingLinkOpts (platformOS (targetPlatform dflags)))- then fmap (:[]) $ mkExtraObj dflags "s" (showSDoc dflags (link_opts link_info))- else return []-- where- link_opts info = hcat [- -- "link info" section (see Note [LinkInfo section])- makeElfNote dflags ghcLinkInfoSectionName ghcLinkInfoNoteName 0 info,-- -- ALL generated assembly must have this section to disable- -- executable stacks. See also- -- compiler/nativeGen/AsmCodeGen.hs for another instance- -- where we need to do this.- if platformHasGnuNonexecStack (targetPlatform dflags)- then text ".section .note.GNU-stack,\"\",@progbits\n"- else Outputable.empty- ]+ PipeState { maybe_loc=maybe_loc} <- getPipeState+ case maybe_loc of+ -- Build a ModLocation to pass to hscMain.+ -- The source filename is rather irrelevant by now, but it's used+ -- by hscMain for messages. hscMain also needs+ -- the .hi and .o filenames. If we already have a ModLocation+ -- then simply update the extensions of the interface and object+ -- files to match the DynFlags, otherwise use the logic in Finder.+ Just l -> return $ l+ { ml_hs_file = Just $ basename <.> suff+ , ml_hi_file = ml_hi_file l -<.> hiSuf dflags+ , ml_obj_file = ml_obj_file l -<.> objectSuf dflags+ }+ _ -> do+ location1 <- liftIO $ mkHomeModLocation2 dflags mod_name basename suff --- | Return the "link info" string------ See Note [LinkInfo section]-getLinkInfo :: DynFlags -> [InstalledUnitId] -> IO String-getLinkInfo dflags dep_packages = do- package_link_opts <- getPackageLinkOpts dflags dep_packages- pkg_frameworks <- if platformUsesFrameworks (targetPlatform dflags)- then getPackageFrameworks dflags dep_packages- else return []- let extra_ld_inputs = ldInputs dflags- let- link_info = (package_link_opts,- pkg_frameworks,- rtsOpts dflags,- rtsOptsEnabled dflags,- gopt Opt_NoHsMain dflags,- map showOpt extra_ld_inputs,- getOpts dflags opt_l)- --- return (show link_info)+ -- Boot-ify it if necessary+ let location2 | HsBootFile <- src_flavour = addBootSuffixLocn location1+ | otherwise = location1 -{- Note [LinkInfo section]- ~~~~~~~~~~~~~~~~~~~~~~~--The "link info" is a string representing the parameters of the link. We save-this information in the binary, and the next time we link, if nothing else has-changed, we use the link info stored in the existing binary to decide whether-to re-link or not.--The "link info" string is stored in a ELF section called ".debug-ghc-link-info"-(see ghcLinkInfoSectionName) with the SHT_NOTE type. For some time, it used to-not follow the specified record-based format (see #11022).---}+ -- Take -ohi into account if present+ -- This can't be done in mkHomeModuleLocation because+ -- it only applies to the module being compiles+ let ohi = outputHi dflags+ location3 | Just fn <- ohi = location2{ ml_hi_file = fn }+ | otherwise = location2 + -- Take -o into account if present+ -- Very like -ohi, but we must *only* do this if we aren't linking+ -- (If we're linking then the -o applies to the linked thing, not to+ -- the object file for one module.)+ -- Note the nasty duplication with the same computation in compileFile+ -- above+ let expl_o_file = outputFile dflags+ location4 | Just ofile <- expl_o_file+ , isNoLink (ghcLink dflags)+ = location3 { ml_obj_file = ofile }+ | otherwise = location3+ return location4 ----------------------------------------------------------------------------- -- Look for the /* GHC_PACKAGES ... */ comment at the top of a .hc file@@ -1892,22 +1786,19 @@ -- Here are some libs that need to be linked at the *end* of -- the command line, because they contain symbols that are referred to -- by the RTS. We can't therefore use the ordinary way opts for these.- let- debug_opts | WayDebug `elem` ways dflags = [+ let debug_opts | WayDebug `elem` ways dflags = [ #if defined(HAVE_LIBBFD) "-lbfd", "-liberty" #endif ]- | otherwise = []+ | otherwise = [] - let thread_opts- | WayThreaded `elem` ways dflags =- let os = platformOS (targetPlatform dflags)- in if os `elem` [OSMinGW32, OSFreeBSD, OSOpenBSD, OSAndroid,- OSNetBSD, OSHaiku, OSQNXNTO, OSiOS, OSDarwin]- then []- else ["-lpthread"]- | otherwise = []+ thread_opts | WayThreaded `elem` ways dflags = [+#if NEED_PTHREAD_LIB+ "-lpthread"+#endif+ ]+ | otherwise = [] rc_objs <- maybeCreateManifest dflags output_fn @@ -1942,7 +1833,7 @@ -- on x86. ++ (if sLdSupportsCompactUnwind mySettings && not staticLink &&- (platformOS platform == OSDarwin || platformOS platform == OSiOS) &&+ (platformOS platform == OSDarwin) && case platformArch platform of ArchX86 -> True ArchX86_64 -> True@@ -1952,13 +1843,6 @@ then ["-Wl,-no_compact_unwind"] else []) - -- '-no_pie'- -- iOS uses 'dynamic-no-pic', so we must pass this to ld to suppress a warning; see #7722- ++ (if platformOS platform == OSiOS &&- not staticLink- then ["-Wl,-no_pie"]- else [])- -- '-Wl,-read_only_relocs,suppress' -- ld gives loads of warnings like: -- ld: warning: text reloc in _base_GHCziArr_unsafeArray_info to _base_GHCziArr_unsafeArray_closure@@ -2038,8 +1922,9 @@ -- the binary itself using windres: if not (gopt Opt_EmbedManifest dflags) then return [] else do - rc_filename <- newTempName dflags "rc"- rc_obj_filename <- newTempName dflags (objectSuf dflags)+ rc_filename <- newTempName dflags TFL_CurrentModule "rc"+ rc_obj_filename <-+ newTempName dflags TFL_GhcSession (objectSuf dflags) writeFile rc_filename $ "1 24 MOVEABLE PURE " ++ show manifest_filename ++ "\n"@@ -2071,13 +1956,36 @@ linkDynLib dflags o_files dep_packages -linkStaticLibCheck :: DynFlags -> [String] -> [InstalledUnitId] -> IO ()-linkStaticLibCheck dflags o_files dep_packages- = do- when (platformOS (targetPlatform dflags) `notElem` [OSiOS, OSDarwin]) $- throwGhcExceptionIO (ProgramError "Static archive creation only supported on Darwin/OS X/iOS")- linkBinary' True dflags o_files dep_packages+-- | Linking a static lib will not really link anything. It will merely produce+-- a static archive of all dependent static libraries. The resulting library+-- will still need to be linked with any remaining link flags.+linkStaticLib :: DynFlags -> [String] -> [InstalledUnitId] -> IO ()+linkStaticLib dflags o_files dep_packages = do+ let extra_ld_inputs = [ f | FileOption _ f <- ldInputs dflags ]+ modules = o_files ++ extra_ld_inputs+ output_fn = exeFileName True dflags + full_output_fn <- if isAbsolute output_fn+ then return output_fn+ else do d <- getCurrentDirectory+ return $ normalise (d </> output_fn)+ output_exists <- doesFileExist full_output_fn+ (when output_exists) $ removeFile full_output_fn++ pkg_cfgs <- getPreloadPackagesAnd dflags dep_packages+ archives <- concat <$> mapM (collectArchives dflags) pkg_cfgs++ ar <- foldl mappend+ <$> (Archive <$> mapM loadObj modules)+ <*> mapM loadAr archives++ if sLdIsGnuLd (settings dflags)+ then writeGNUAr output_fn $ afilter (not . isGNUSymdef) ar+ else writeBSDAr output_fn $ afilter (not . isBSDSymdef) ar++ -- run ranlib over the archive. write*Ar does *not* create the symbol index.+ runRanlib dflags [SysTools.FileOption "" output_fn]+ -- ----------------------------------------------------------------------------- -- Running CPP @@ -2128,7 +2036,7 @@ pkgs = catMaybes (map (lookupPackage dflags) uids) mb_macro_include <- if not (null pkgs) && gopt Opt_VersionMacros dflags- then do macro_stub <- newTempName dflags "h"+ then do macro_stub <- newTempName dflags TFL_CurrentModule "h" writeFile macro_stub (generatePackageVersionMacros pkgs) -- Include version macros for every *exposed* package. -- Without -hide-all-packages and with a package database@@ -2255,14 +2163,14 @@ ccInfo <- getCompilerInfo dflags if ldIsGnuLd then do- script <- newTempName dflags "ldscript"+ script <- newTempName dflags TFL_CurrentModule "ldscript" cwd <- getCurrentDirectory let o_files_abs = map (\x -> "\"" ++ (cwd </> x) ++ "\"") o_files writeFile script $ "INPUT(" ++ unwords o_files_abs ++ ")" ld_r [SysTools.FileOption "" script] ccInfo else if sLdSupportsFilelist mySettings then do- filelist <- newTempName dflags "filelist"+ filelist <- newTempName dflags TFL_CurrentModule "filelist" writeFile filelist $ unlines o_files ld_r [SysTools.Option "-Wl,-filelist", SysTools.FileOption "-Wl," filelist] ccInfo@@ -2295,20 +2203,19 @@ createDirectoryIfMissing True $ takeDirectory path SysTools.touch dflags "Touching object file" path -haveRtsOptsFlags :: DynFlags -> Bool-haveRtsOptsFlags dflags =- isJust (rtsOpts dflags) || case rtsOptsEnabled dflags of- RtsOptsSafeOnly -> False- _ -> True- -- | Find out path to @ghcversion.h@ file getGhcVersionPathName :: DynFlags -> IO FilePath getGhcVersionPathName dflags = do- dirs <- getPackageIncludePath dflags [toInstalledUnitId rtsUnitId]+ candidates <- case ghcVersionFile dflags of+ Just path -> return [path]+ Nothing -> (map (</> "ghcversion.h")) <$>+ (getPackageIncludePath dflags [toInstalledUnitId rtsUnitId]) - found <- filterM doesFileExist (map (</> "ghcversion.h") dirs)+ found <- filterM doesFileExist candidates case found of- [] -> throwGhcExceptionIO (InstallationError ("ghcversion.h missing"))+ [] -> throwGhcExceptionIO (InstallationError+ ("ghcversion.h missing; tried: "+ ++ intercalate ", " candidates)) (x:_) -> return x -- Note [-fPIC for assembler]
main/DynFlags.hs view
@@ -60,6 +60,7 @@ makeDynFlagsConsistent, shouldUseColor, positionIndependent,+ optimisationFlags, Way(..), mkBuildTag, wayRTSOnly, addWay', updateWays, wayGeneralFlags, wayUnsetGeneralFlags,@@ -76,6 +77,9 @@ safeDirectImpsReq, safeImplicitImpsReq, unsafeFlags, unsafeFlagsForInfer, + -- ** LLVM Targets+ LlvmTarget(..), LlvmTargets,+ -- ** System tool settings and locations Settings(..), targetPlatform, programName, projectVersion,@@ -83,12 +87,12 @@ versionedAppDir, extraGccViaCFlags, systemPackageConfig, pgm_L, pgm_P, pgm_F, pgm_c, pgm_s, pgm_a, pgm_l, pgm_dll, pgm_T,- pgm_windres, pgm_libtool, pgm_lo, pgm_lc, pgm_i,- opt_L, opt_P, opt_F, opt_c, opt_a, opt_l, opt_i,- opt_windres, opt_lo, opt_lc,-+ pgm_windres, pgm_libtool, pgm_ar, pgm_ranlib, pgm_lo, pgm_lc,+ pgm_lcc, pgm_i, opt_L, opt_P, opt_F, opt_c, opt_a, opt_l, opt_i,+ opt_windres, opt_lo, opt_lc, opt_lcc, -- ** Manipulating DynFlags+ addPluginModuleName, defaultDynFlags, -- Settings -> DynFlags defaultWays, interpWays,@@ -146,6 +150,8 @@ isSseEnabled, isSse2Enabled, isSse4_2Enabled,+ isBmiEnabled,+ isBmi2Enabled, isAvxEnabled, isAvx2Enabled, isAvx512cdEnabled,@@ -156,10 +162,15 @@ -- * Linker/compiler information LinkerInfo(..), CompilerInfo(..),++ -- * File cleanup+ FilesToClean(..), emptyFilesToClean ) where #include "HsVersions.h" +import GhcPrelude+ import Platform import PlatformConstants import Module@@ -169,7 +180,8 @@ import {-# SOURCE #-} Packages (PackageState, emptyPackageState) import DriverPhases ( Phase(..), phaseInputExt ) import Config-import CmdLineParser+import CmdLineParser hiding (WarnReason(..))+import qualified CmdLineParser as Cmd import Constants import Panic import qualified PprColour as Col@@ -187,6 +199,7 @@ , getCaretDiagnostic, dumpSDoc ) import Json import SysTools.Terminal ( stderrSupportsAnsiColors )+import SysTools.BaseDir ( expandTopDir ) import System.IO.Unsafe ( unsafePerformIO ) import Data.IORef@@ -216,8 +229,8 @@ import Text.ParserCombinators.ReadP hiding (char) import Text.ParserCombinators.ReadP as R -import Data.IntSet (IntSet)-import qualified Data.IntSet as IntSet+import EnumSet (EnumSet)+import qualified EnumSet import GHC.Foreign (withCString, peekCString) import qualified GHC.LanguageExtensions as LangExt@@ -228,14 +241,8 @@ -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- -- If you modify anything in this file please make sure that your changes are--- described in the User's Guide. Usually at least two sections need to be--- updated:------ * Flag Reference section generated from the modules in--- utils/mkUserGuidePart/Options------ * Flag description in docs/users_guide/using.rst provides a detailed--- explanation of flags' usage.+-- described in the User's Guide. Please update the flag description in the+-- users guide (docs/users_guide) whenever you add or change a flag. -- Note [Supporting CLI completion] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -357,6 +364,7 @@ | Opt_D_dump_prep | Opt_D_dump_stg | Opt_D_dump_call_arity+ | Opt_D_dump_exitify | Opt_D_dump_stranal | Opt_D_dump_str_signatures | Opt_D_dump_tc@@ -386,6 +394,7 @@ | Opt_D_dump_hi_diffs | Opt_D_dump_mod_cycles | Opt_D_dump_mod_map+ | Opt_D_dump_timings | Opt_D_dump_view_pattern_commoning | Opt_D_verbose_core2core | Opt_D_dump_debug@@ -394,6 +403,7 @@ | Opt_D_no_debug_output deriving (Eq, Show, Enum) + -- | Enumerates the simple on-or-off dynamic flags data GeneralFlag -- See Note [Updating flag description in the User's Guide]@@ -407,6 +417,7 @@ | Opt_DoAsmLinting | Opt_DoAnnotationLinting | Opt_NoLlvmMangler -- hidden flag+ | Opt_FastLlvm -- hidden flag | Opt_WarnIsError -- -Werror; makes warnings fatal | Opt_ShowWarnGroups -- Show the group a warning belongs to@@ -424,6 +435,7 @@ -- optimisation opts | Opt_CallArity+ | Opt_Exitification | Opt_Strictness | Opt_LateDmdAnal | Opt_KillAbsence@@ -467,7 +479,13 @@ | Opt_CprAnal | Opt_WorkerWrapper | Opt_SolveConstantDicts+ | Opt_AlignmentSanitisation+ | Opt_CatchBottoms + -- PreInlining is on by default. The option is there just to see how+ -- bad things get if you turn it off!+ | Opt_SimplPreInlining+ -- Interface files | Opt_IgnoreInterfacePragmas | Opt_OmitInterfacePragmas@@ -481,6 +499,8 @@ -- misc opts | Opt_Pp | Opt_ForceRecomp+ | Opt_IgnoreOptimChanges+ | Opt_IgnoreHpcChanges | Opt_ExcessPrecision | Opt_EagerBlackHoling | Opt_NoHsMain@@ -525,10 +545,6 @@ | Opt_VersionMacros | Opt_WholeArchiveHsLibs - -- PreInlining is on by default. The option is there just to see how- -- bad things get if you turn it off!- | Opt_SimplPreInlining- -- output style opts | Opt_ErrorSpans -- Include full span info in error messages, -- instead of just the start position.@@ -556,6 +572,7 @@ -- Except for uniques, as some simplifier phases introduce new -- variables that have otherwise identical names. | Opt_SuppressUniques+ | Opt_SuppressStgFreeVars | Opt_SuppressTicks -- Replaces Opt_PprShowTicks -- temporary flags@@ -582,10 +599,74 @@ | Opt_G_NoOptCoercion deriving (Eq, Show, Enum) +-- Check whether a flag should be considered an "optimisation flag"+-- for purposes of recompilation avoidance (see+-- Note [Ignoring some flag changes] in FlagChecker). Being listed here is+-- not a guarantee that the flag has no other effect. We could, and+-- perhaps should, separate out the flags that have some minor impact on+-- program semantics and/or error behavior (e.g., assertions), but+-- then we'd need to go to extra trouble (and an additional flag)+-- to allow users to ignore the optimisation level even though that+-- means ignoring some change.+optimisationFlags :: EnumSet GeneralFlag+optimisationFlags = EnumSet.fromList+ [ Opt_CallArity+ , Opt_Strictness+ , Opt_LateDmdAnal+ , Opt_KillAbsence+ , Opt_KillOneShot+ , Opt_FullLaziness+ , Opt_FloatIn+ , Opt_Specialise+ , Opt_SpecialiseAggressively+ , Opt_CrossModuleSpecialise+ , Opt_StaticArgumentTransformation+ , Opt_CSE+ , Opt_StgCSE+ , Opt_LiberateCase+ , Opt_SpecConstr+ , Opt_SpecConstrKeen+ , Opt_DoLambdaEtaExpansion+ , Opt_IgnoreAsserts+ , Opt_DoEtaReduction+ , Opt_CaseMerge+ , Opt_CaseFolding+ , Opt_UnboxStrictFields+ , Opt_UnboxSmallStrictFields+ , Opt_DictsCheap+ , Opt_EnableRewriteRules+ , Opt_Vectorise+ , Opt_VectorisationAvoidance+ , Opt_RegsGraph+ , Opt_RegsIterative+ , Opt_PedanticBottoms+ , Opt_LlvmTBAA+ , Opt_LlvmPassVectorsInRegisters+ , Opt_LlvmFillUndefWithGarbage+ , Opt_IrrefutableTuples+ , Opt_CmmSink+ , Opt_CmmElimCommonBlocks+ , Opt_OmitYields+ , Opt_FunToThunk+ , Opt_DictsStrict+ , Opt_DmdTxDictSel+ , Opt_Loopification+ , Opt_CprAnal+ , Opt_WorkerWrapper+ , Opt_SolveConstantDicts+ , Opt_CatchBottoms+ , Opt_IgnoreAsserts+ ]+ -- | Used when outputting warnings: if a reason is given, it is -- displayed. If a warning isn't controlled by a flag, this is made -- explicit at the point of use.-data WarnReason = NoReason | Reason !WarningFlag+data WarnReason+ = NoReason+ -- | Warning was enabled with the flag+ | Reason !WarningFlag+ -- | Warning was made an error because of -Werror or -Werror=WarningFlag+ | ErrReason !(Maybe WarningFlag) deriving Show instance Outputable WarnReason where@@ -594,6 +675,8 @@ instance ToJson WarnReason where json NoReason = JSNull json (Reason wf) = JSString (show wf)+ json (ErrReason Nothing) = JSString "Opt_WarnIsError"+ json (ErrReason (Just wf)) = JSString (show wf) data WarningFlag = -- See Note [Updating flag description in the User's Guide]@@ -663,6 +746,8 @@ | Opt_WarnCPPUndef -- Since 8.2 | Opt_WarnUnbangedStrictPatterns -- Since 8.2 | Opt_WarnMissingHomeModules -- Since 8.2+ | Opt_WarnPartialFields -- Since 8.4+ | Opt_WarnMissingExportList deriving (Eq, Show, Enum) data Language = Haskell98 | Haskell2010@@ -695,6 +780,7 @@ ghcLink :: GhcLink, hscTarget :: HscTarget, settings :: Settings,+ llvmTargets :: LlvmTargets, verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels] optLevel :: Int, -- ^ Optimisation level debugLevel :: Int, -- ^ How much debug information to produce@@ -713,6 +799,8 @@ maxRelevantBinds :: Maybe Int, -- ^ Maximum number of bindings from the type envt -- to show in type error messages+ maxValidSubstitutions :: Maybe Int, -- ^ Maximum number of substitutions+ -- to show in type error messages maxUncoveredPatterns :: Int, -- ^ Maximum number of unmatched patterns to show -- in non-exhaustiveness warnings simplTickFactor :: Int, -- ^ Multiplier for simplifier ticks@@ -740,7 +828,6 @@ -- ways ways :: [Way], -- ^ Way flags from the command line buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)- rtsBuildTag :: String, -- ^ The RTS \"way\" -- For object splitting splitInfo :: Maybe (String,Int),@@ -760,14 +847,6 @@ dynObjectSuf :: String, dynHiSuf :: String, - -- Packages.isDllName needs to know whether a call is within a- -- single DLL or not. Normally it does this by seeing if the call- -- is to the same package, but for the ghc package, we split the- -- package between 2 DLLs. The dllSplit tells us which sets of- -- modules are in which package.- dllSplitFile :: Maybe FilePath,- dllSplit :: Maybe [Set String],- outputFile :: Maybe String, dynOutputFile :: Maybe String, outputHi :: Maybe String,@@ -842,9 +921,8 @@ -- Temporary files -- These have to be IORefs, because the defaultCleanupHandler needs to -- know what to clean when an exception happens- filesToClean :: IORef [FilePath],+ filesToClean :: IORef FilesToClean, dirsToClean :: IORef (Map FilePath FilePath),- filesToNotIntermediateClean :: IORef [FilePath], -- The next available suffix to uniquely name a temp file, updated atomically nextTempSuffix :: IORef Int, @@ -854,10 +932,10 @@ generatedDumps :: IORef (Set FilePath), -- hsc dynamic flags- dumpFlags :: IntSet,- generalFlags :: IntSet,- warningFlags :: IntSet,- fatalWarningFlags :: IntSet,+ dumpFlags :: EnumSet DumpFlag,+ generalFlags :: EnumSet GeneralFlag,+ warningFlags :: EnumSet WarningFlag,+ fatalWarningFlags :: EnumSet WarningFlag, -- Don't change this without updating extensionFlags: language :: Maybe Language, -- | Safe Haskell mode@@ -881,7 +959,7 @@ -- flattenExtensionFlags language extensions -- LangExt.Extension is defined in libraries/ghc-boot so that it can be used -- by template-haskell- extensionFlags :: IntSet,+ extensionFlags :: EnumSet LangExt.Extension, -- Unfolding control -- See Note [Discounts and thresholds] in CoreUnfold@@ -904,6 +982,7 @@ flushOut :: FlushOut, flushErr :: FlushErr, + ghcVersionFile :: Maybe FilePath, haddockOptions :: Maybe String, -- | GHCi scripts specified by -ghci-script, in reverse order@@ -927,6 +1006,7 @@ -- | Machine dependent flags (-m<blah> stuff) sseVersion :: Maybe SseVersion,+ bmiVersion :: Maybe BmiVersion, avx :: Bool, avx2 :: Bool, avx512cd :: Bool, -- Enable AVX-512 Conflict Detection Instructions.@@ -999,6 +1079,14 @@ | ProfAutoCalls -- ^ annotate call-sites deriving (Eq,Enum) +data LlvmTarget = LlvmTarget+ { lDataLayout :: String+ , lCPU :: String+ , lAttributes :: [String]+ }++type LlvmTargets = [(String, LlvmTarget)]+ data Settings = Settings { sTargetPlatform :: Platform, -- Filled in by SysTools sGhcUsagePath :: FilePath, -- Filled in by SysTools@@ -1029,8 +1117,11 @@ sPgm_T :: String, sPgm_windres :: String, sPgm_libtool :: String,+ sPgm_ar :: String,+ sPgm_ranlib :: String, sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler+ sPgm_lcc :: (String,[Option]), -- LLVM: c compiler sPgm_i :: String, -- options for particular phases sOpt_L :: [String],@@ -1042,6 +1133,7 @@ sOpt_windres :: [String], sOpt_lo :: [String], -- LLVM: llvm optimiser sOpt_lc :: [String], -- LLVM: llc static compiler+ sOpt_lcc :: [String], -- LLVM: c compiler sOpt_i :: [String], -- iserv options sPlatformConstants :: PlatformConstants@@ -1089,6 +1181,12 @@ pgm_windres dflags = sPgm_windres (settings dflags) pgm_libtool :: DynFlags -> String pgm_libtool dflags = sPgm_libtool (settings dflags)+pgm_lcc :: DynFlags -> (String,[Option])+pgm_lcc dflags = sPgm_lcc (settings dflags)+pgm_ar :: DynFlags -> String+pgm_ar dflags = sPgm_ar (settings dflags)+pgm_ranlib :: DynFlags -> String+pgm_ranlib dflags = sPgm_ranlib (settings dflags) pgm_lo :: DynFlags -> (String,[Option]) pgm_lo dflags = sPgm_lo (settings dflags) pgm_lc :: DynFlags -> (String,[Option])@@ -1112,6 +1210,8 @@ ++ sOpt_l (settings dflags) opt_windres :: DynFlags -> [String] opt_windres dflags = sOpt_windres (settings dflags)+opt_lcc :: DynFlags -> [String]+opt_lcc dflags = sOpt_lcc (settings dflags) opt_lo :: DynFlags -> [String] opt_lo dflags = sOpt_lo (settings dflags) opt_lc :: DynFlags -> [String]@@ -1146,12 +1246,10 @@ -- 'HscNothing' can be used to avoid generating any output, however, note -- that: ----- * If a program uses Template Haskell the typechecker may try to run code--- from an imported module. This will fail if no code has been generated--- for this module. You can use 'GHC.needsTemplateHaskell' to detect--- whether this might be the case and choose to either switch to a--- different target or avoid typechecking such modules. (The latter may be--- preferable for security reasons.)+-- * If a program uses Template Haskell the typechecker may need to run code+-- from an imported module. To facilitate this, code generation is enabled+-- for modules imported by modules that use template haskell.+-- See Note [-fno-code mode]. -- data HscTarget = HscC -- ^ Generate C code.@@ -1313,7 +1411,9 @@ | SystemDependent deriving Eq -data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll+data RtsOptsEnabled+ = RtsOptsNone | RtsOptsIgnore | RtsOptsIgnoreAll | RtsOptsSafeOnly+ | RtsOptsAll deriving (Show) shouldUseColor :: DynFlags -> Bool@@ -1508,9 +1608,8 @@ = platformOS (targetPlatform dflags) /= OSMinGW32 refCanGenerateDynamicToo <- newIORef platformCanGenerateDynamicToo refNextTempSuffix <- newIORef 0- refFilesToClean <- newIORef []+ refFilesToClean <- newIORef emptyFilesToClean refDirsToClean <- newIORef Map.empty- refFilesToNotIntermediateClean <- newIORef [] refGeneratedDumps <- newIORef Set.empty refRtldInfo <- newIORef Nothing refRtccInfo <- newIORef Nothing@@ -1534,7 +1633,6 @@ nextTempSuffix = refNextTempSuffix, filesToClean = refFilesToClean, dirsToClean = refDirsToClean,- filesToNotIntermediateClean = refFilesToNotIntermediateClean, generatedDumps = refGeneratedDumps, nextWrapperNum = wrapperNum, useUnicode = canUseUnicode,@@ -1547,8 +1645,8 @@ -- | The normal 'DynFlags'. Note that they are not suitable for use in this form -- and must be fully initialized by 'GHC.runGhc' first.-defaultDynFlags :: Settings -> DynFlags-defaultDynFlags mySettings =+defaultDynFlags :: Settings -> LlvmTargets -> DynFlags+defaultDynFlags mySettings myLlvmTargets = -- See Note [Updating flag description in the User's Guide] DynFlags { ghcMode = CompManager,@@ -1562,6 +1660,7 @@ maxPmCheckIterations = 2000000, ruleCheck = Nothing, maxRelevantBinds = Just 6,+ maxValidSubstitutions = Just 6, maxUncoveredPatterns = 4, simplTickFactor = 100, specConstrThreshold = Just 2000,@@ -1602,9 +1701,6 @@ dynObjectSuf = "dyn_" ++ phaseInputExt StopLn, dynHiSuf = "dyn_hi", - dllSplitFile = Nothing,- dllSplit = Nothing,- pluginModNames = [], pluginModNameOpts = [], frontendPluginOpts = [],@@ -1638,9 +1734,10 @@ pkgState = emptyPackageState, ways = defaultWays mySettings, buildTag = mkBuildTag (defaultWays mySettings),- rtsBuildTag = mkBuildTag (defaultWays mySettings), splitInfo = Nothing, settings = mySettings,+ llvmTargets = myLlvmTargets,+ -- ghc -M values depMakefile = "Makefile", depIncludePkgDeps = False,@@ -1650,13 +1747,13 @@ nextTempSuffix = panic "defaultDynFlags: No nextTempSuffix", filesToClean = panic "defaultDynFlags: No filesToClean", dirsToClean = panic "defaultDynFlags: No dirsToClean",- filesToNotIntermediateClean = panic "defaultDynFlags: No filesToNotIntermediateClean", generatedDumps = panic "defaultDynFlags: No generatedDumps",+ ghcVersionFile = Nothing, haddockOptions = Nothing,- dumpFlags = IntSet.empty,- generalFlags = IntSet.fromList (map fromEnum (defaultFlags mySettings)),- warningFlags = IntSet.fromList (map fromEnum standardWarnings),- fatalWarningFlags = IntSet.empty,+ dumpFlags = EnumSet.empty,+ generalFlags = EnumSet.fromList (defaultFlags mySettings),+ warningFlags = EnumSet.fromList standardWarnings,+ fatalWarningFlags = EnumSet.empty, ghciScripts = [], language = Nothing, safeHaskell = Sf_None,@@ -1711,6 +1808,7 @@ interactivePrint = Nothing, nextWrapperNum = panic "defaultDynFlags: No nextWrapperNum", sseVersion = Nothing,+ bmiVersion = Nothing, avx = False, avx2 = False, avx512cd = False,@@ -1830,35 +1928,49 @@ SevInteractive -> putStrSDoc msg style SevInfo -> printErrs msg style SevFatal -> printErrs msg style- _ -> do -- otherwise (i.e. SevError or SevWarning)- hPutChar stderr '\n'- caretDiagnostic <-- if gopt Opt_DiagnosticsShowCaret dflags- then getCaretDiagnostic severity srcSpan- else pure empty- printErrs (message $+$ caretDiagnostic)- (setStyleColoured True style)- -- careful (#2302): printErrs prints in UTF-8,- -- whereas converting to string first and using- -- hPutStr would just emit the low 8 bits of- -- each unicode char.- where printOut = defaultLogActionHPrintDoc dflags stdout- printErrs = defaultLogActionHPrintDoc dflags stderr- putStrSDoc = defaultLogActionHPutStrDoc dflags stdout- -- Pretty print the warning flag, if any (#10752)- message = mkLocMessageAnn flagMsg severity srcSpan msg- flagMsg = case reason of- NoReason -> Nothing- Reason flag -> (\spec -> "-W" ++ flagSpecName spec ++ flagGrp flag) <$>- flagSpecOf flag+ SevWarning -> printWarns+ SevError -> printWarns+ where+ printOut = defaultLogActionHPrintDoc dflags stdout+ printErrs = defaultLogActionHPrintDoc dflags stderr+ putStrSDoc = defaultLogActionHPutStrDoc dflags stdout+ -- Pretty print the warning flag, if any (#10752)+ message = mkLocMessageAnn flagMsg severity srcSpan msg - flagGrp flag- | gopt Opt_ShowWarnGroups dflags =- case smallestGroups flag of- [] -> ""- groups -> " (in " ++ intercalate ", " (map ("-W"++) groups) ++ ")"- | otherwise = ""+ printWarns = do+ hPutChar stderr '\n'+ caretDiagnostic <-+ if gopt Opt_DiagnosticsShowCaret dflags+ then getCaretDiagnostic severity srcSpan+ else pure empty+ printErrs (message $+$ caretDiagnostic)+ (setStyleColoured True style)+ -- careful (#2302): printErrs prints in UTF-8,+ -- whereas converting to string first and using+ -- hPutStr would just emit the low 8 bits of+ -- each unicode char. + flagMsg =+ case reason of+ NoReason -> Nothing+ Reason wflag -> do+ spec <- flagSpecOf wflag+ return ("-W" ++ flagSpecName spec ++ warnFlagGrp wflag)+ ErrReason Nothing ->+ return "-Werror"+ ErrReason (Just wflag) -> do+ spec <- flagSpecOf wflag+ return $+ "-W" ++ flagSpecName spec ++ warnFlagGrp wflag +++ ", -Werror=" ++ flagSpecName spec++ warnFlagGrp flag+ | gopt Opt_ShowWarnGroups dflags =+ case smallestGroups flag of+ [] -> ""+ groups -> " (in " ++ intercalate ", " (map ("-W"++) groups) ++ ")"+ | otherwise = ""+ -- | Like 'defaultLogActionHPutStrDoc' but appends an extra newline. defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO () defaultLogActionHPrintDoc dflags h d sty@@ -1901,11 +2013,11 @@ -- OnOffs accumulate in reverse order, so we use foldr in order to -- process them in the right order-flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> IntSet+flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> EnumSet LangExt.Extension flattenExtensionFlags ml = foldr f defaultExtensionFlags- where f (On f) flags = IntSet.insert (fromEnum f) flags- f (Off f) flags = IntSet.delete (fromEnum f) flags- defaultExtensionFlags = IntSet.fromList (map fromEnum (languageExtensions ml))+ where f (On f) flags = EnumSet.insert f flags+ f (Off f) flags = EnumSet.delete f flags+ defaultExtensionFlags = EnumSet.fromList (languageExtensions ml) languageExtensions :: Maybe Language -> [LangExt.Extension] @@ -1960,7 +2072,7 @@ -- | Test whether a 'DumpFlag' is set dopt :: DumpFlag -> DynFlags -> Bool-dopt f dflags = (fromEnum f `IntSet.member` dumpFlags dflags)+dopt f dflags = (f `EnumSet.member` dumpFlags dflags) || (verbosity dflags >= 4 && enableIfVerbose f) where enableIfVerbose Opt_D_dump_tc_trace = False enableIfVerbose Opt_D_dump_rn_trace = False@@ -1994,55 +2106,53 @@ -- | Set a 'DumpFlag' dopt_set :: DynFlags -> DumpFlag -> DynFlags-dopt_set dfs f = dfs{ dumpFlags = IntSet.insert (fromEnum f) (dumpFlags dfs) }+dopt_set dfs f = dfs{ dumpFlags = EnumSet.insert f (dumpFlags dfs) } -- | Unset a 'DumpFlag' dopt_unset :: DynFlags -> DumpFlag -> DynFlags-dopt_unset dfs f = dfs{ dumpFlags = IntSet.delete (fromEnum f) (dumpFlags dfs) }+dopt_unset dfs f = dfs{ dumpFlags = EnumSet.delete f (dumpFlags dfs) } -- | Test whether a 'GeneralFlag' is set gopt :: GeneralFlag -> DynFlags -> Bool-gopt f dflags = fromEnum f `IntSet.member` generalFlags dflags+gopt f dflags = f `EnumSet.member` generalFlags dflags -- | Set a 'GeneralFlag' gopt_set :: DynFlags -> GeneralFlag -> DynFlags-gopt_set dfs f = dfs{ generalFlags = IntSet.insert (fromEnum f) (generalFlags dfs) }+gopt_set dfs f = dfs{ generalFlags = EnumSet.insert f (generalFlags dfs) } -- | Unset a 'GeneralFlag' gopt_unset :: DynFlags -> GeneralFlag -> DynFlags-gopt_unset dfs f = dfs{ generalFlags = IntSet.delete (fromEnum f) (generalFlags dfs) }+gopt_unset dfs f = dfs{ generalFlags = EnumSet.delete f (generalFlags dfs) } -- | Test whether a 'WarningFlag' is set wopt :: WarningFlag -> DynFlags -> Bool-wopt f dflags = fromEnum f `IntSet.member` warningFlags dflags+wopt f dflags = f `EnumSet.member` warningFlags dflags -- | Set a 'WarningFlag' wopt_set :: DynFlags -> WarningFlag -> DynFlags-wopt_set dfs f = dfs{ warningFlags = IntSet.insert (fromEnum f) (warningFlags dfs) }+wopt_set dfs f = dfs{ warningFlags = EnumSet.insert f (warningFlags dfs) } -- | Unset a 'WarningFlag' wopt_unset :: DynFlags -> WarningFlag -> DynFlags-wopt_unset dfs f = dfs{ warningFlags = IntSet.delete (fromEnum f) (warningFlags dfs) }+wopt_unset dfs f = dfs{ warningFlags = EnumSet.delete f (warningFlags dfs) } -- | Test whether a 'WarningFlag' is set as fatal wopt_fatal :: WarningFlag -> DynFlags -> Bool-wopt_fatal f dflags = fromEnum f `IntSet.member` fatalWarningFlags dflags+wopt_fatal f dflags = f `EnumSet.member` fatalWarningFlags dflags -- | Mark a 'WarningFlag' as fatal (do not set the flag) wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags wopt_set_fatal dfs f- = dfs { fatalWarningFlags =- IntSet.insert (fromEnum f) (fatalWarningFlags dfs) }+ = dfs { fatalWarningFlags = EnumSet.insert f (fatalWarningFlags dfs) } -- | Mark a 'WarningFlag' as not fatal wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags wopt_unset_fatal dfs f- = dfs { fatalWarningFlags =- IntSet.delete (fromEnum f) (fatalWarningFlags dfs) }+ = dfs { fatalWarningFlags = EnumSet.delete f (fatalWarningFlags dfs) } -- | Test whether a 'LangExt.Extension' is set xopt :: LangExt.Extension -> DynFlags -> Bool-xopt f dflags = fromEnum f `IntSet.member` extensionFlags dflags+xopt f dflags = f `EnumSet.member` extensionFlags dflags -- | Set a 'LangExt.Extension' xopt_set :: DynFlags -> LangExt.Extension -> DynFlags@@ -2296,6 +2406,9 @@ addCmdlineFramework f d = d { cmdlineFrameworks = f : cmdlineFrameworks d} +addGhcVersionFile :: FilePath -> DynFlags -> DynFlags+addGhcVersionFile f d = d { ghcVersionFile = Just f }+ addHaddockOpts f d = d { haddockOptions = Just f} addGhciScript f d = d { ghciScripts = f : ghciScripts d}@@ -2353,7 +2466,7 @@ -- Throws a 'UsageError' if errors occurred during parsing (such as unknown -- flags or missing arguments). parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String]- -> m (DynFlags, [Located String], [Located String])+ -> m (DynFlags, [Located String], [Warn]) -- ^ Updated 'DynFlags', left-over arguments, and -- list of warnings. parseDynamicFlagsCmdLine = parseDynamicFlagsFull flagsAll True@@ -2363,7 +2476,7 @@ -- (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db). -- Used to parse flags set in a modules pragma. parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String]- -> m (DynFlags, [Located String], [Located String])+ -> m (DynFlags, [Located String], [Warn]) -- ^ Updated 'DynFlags', left-over arguments, and -- list of warnings. parseDynamicFilePragma = parseDynamicFlagsFull flagsDynamic False@@ -2378,14 +2491,14 @@ -> Bool -- ^ are the arguments from the command line? -> DynFlags -- ^ current dynamic flags -> [Located String] -- ^ arguments to parse- -> m (DynFlags, [Located String], [Located String])+ -> m (DynFlags, [Located String], [Warn]) parseDynamicFlagsFull activeFlags cmdline dflags0 args = do let ((leftover, errs, warns), dflags1) = runCmdLine (processArgs activeFlags args) dflags0 -- See Note [Handling errors when parsing commandline flags]- unless (null errs) $ liftIO $ throwGhcExceptionIO $- errorsToGhcException . map (showPpr dflags0 . getLoc &&& unLoc) $ errs+ unless (null errs) $ liftIO $ throwGhcExceptionIO $ errorsToGhcException $+ map ((showPpr dflags0 . getLoc &&& unLoc) . errMsg) $ errs -- check for disabled flags in safe haskell let (dflags2, sh_warns) = safeFlagCheck cmdline dflags1@@ -2408,32 +2521,20 @@ let (dflags5, consistency_warnings) = makeDynFlagsConsistent dflags4 - dflags6 <- case dllSplitFile dflags5 of- Nothing -> return (dflags5 { dllSplit = Nothing })- Just f ->- case dllSplit dflags5 of- Just _ ->- -- If dllSplit is out of date then it would have- -- been set to Nothing. As it's a Just, it must be- -- up-to-date.- return dflags5- Nothing ->- do xs <- liftIO $ readFile f- let ss = map (Set.fromList . words) (lines xs)- return $ dflags5 { dllSplit = Just ss }- -- Set timer stats & heap size- when (enableTimeStats dflags6) $ liftIO enableTimingStats- case (ghcHeapSize dflags6) of+ when (enableTimeStats dflags5) $ liftIO enableTimingStats+ case (ghcHeapSize dflags5) of Just x -> liftIO (setHeapSize x) _ -> return () - dflags7 <- liftIO $ setLogAction dflags6+ dflags7 <- liftIO $ setLogAction dflags5 liftIO $ setUnsafeGlobalDynFlags dflags7 - return (dflags7, leftover, consistency_warnings ++ sh_warns ++ warns)+ let warns' = map (Warn Cmd.NoReason) (consistency_warnings ++ sh_warns) + return (dflags7, leftover, warns' ++ warns)+ setLogAction :: DynFlags -> IO DynFlags setLogAction dflags = do mlogger <- initLogAction dflags@@ -2458,8 +2559,7 @@ = let theWays = sort $ nub $ ways dflags in dflags { ways = theWays,- buildTag = mkBuildTag (filter (not . wayRTSOnly) theWays),- rtsBuildTag = mkBuildTag theWays+ buildTag = mkBuildTag (filter (not . wayRTSOnly) theWays) } -- | Check (and potentially disable) any extensions that aren't allowed@@ -2598,8 +2698,8 @@ , make_ord_flag defFlag "F" (NoArg (setGeneralFlag Opt_Pp)) , (Deprecated, defFlag "#include" (HasArg (\_s ->- addWarn ("-#include and INCLUDE pragmas are " ++- "deprecated: They no longer have any effect"))))+ deprecate ("-#include and INCLUDE pragmas are " +++ "deprecated: They no longer have any effect")))) , make_ord_flag defFlag "v" (OptIntSuffix setVerbosity) , make_ord_flag defGhcFlag "j" (OptIntSuffix@@ -2641,7 +2741,7 @@ , make_ord_flag defGhcFlag "static" (NoArg removeWayDyn) , make_ord_flag defGhcFlag "dynamic" (NoArg (addWay WayDyn)) , make_ord_flag defGhcFlag "rdynamic" $ noArg $-#ifdef linux_HOST_OS+#if defined(linux_HOST_OS) addOptl "-rdynamic" #elif defined (mingw32_HOST_OS) addOptl "-Wl,--export-all-symbols"@@ -2682,7 +2782,12 @@ (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f}))) , make_ord_flag defFlag "pgmlibtool" (hasArg (\f -> alterSettings (\s -> s { sPgm_libtool = f})))+ , make_ord_flag defFlag "pgmar"+ (hasArg (\f -> alterSettings (\s -> s { sPgm_ar = f})))+ , make_ord_flag defFlag "pgmranlib"+ (hasArg (\f -> alterSettings (\s -> s { sPgm_ranlib = f}))) + -- need to appear before -optl/-opta to be parsed as LLVM flags. , make_ord_flag defFlag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))@@ -2709,7 +2814,7 @@ , make_ord_flag defGhcFlag "split-objs" (NoArg (if can_split then setGeneralFlag Opt_SplitObjs- else addWarn "ignoring -fsplit-objs"))+ else addWarn "ignoring -split-objs")) , make_ord_flag defGhcFlag "split-sections" (noArgM (\dflags -> do@@ -2736,9 +2841,6 @@ (noArg (\d -> d { ghcLink=LinkStaticLib })) , make_ord_flag defGhcFlag "dynload" (hasArg parseDynLibLoaderMode) , make_ord_flag defGhcFlag "dylib-install-name" (hasArg setDylibInstallName)- -- -dll-split is an internal flag, used only during the GHC build- , make_ord_flag defHiddenFlag "dll-split"- (hasArg (\f d -> d { dllSplitFile = Just f, dllSplit = Nothing })) ------- Libraries --------------------------------------------------- , make_ord_flag defFlag "L" (Prefix addLibraryPath)@@ -2825,11 +2927,16 @@ (NoArg (setRtsOptsEnabled RtsOptsSafeOnly)) , make_ord_flag defGhcFlag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))+ , make_ord_flag defGhcFlag "rtsopts=ignore"+ (NoArg (setRtsOptsEnabled RtsOptsIgnore))+ , make_ord_flag defGhcFlag "rtsopts=ignoreAll"+ (NoArg (setRtsOptsEnabled RtsOptsIgnoreAll)) , make_ord_flag defGhcFlag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone)) , make_ord_flag defGhcFlag "no-rtsopts-suggestions" (noArg (\d -> d {rtsOptsSuggestions = False})) + , make_ord_flag defGhcFlag "ghcversion-file" (hasArg addGhcVersionFile) , make_ord_flag defGhcFlag "main-is" (SepArg setMainIs) , make_ord_flag defGhcFlag "haddock" (NoArg (setGeneralFlag Opt_Haddock)) , make_ord_flag defGhcFlag "haddock-opts" (hasArg addHaddockOpts)@@ -2887,6 +2994,7 @@ setGeneralFlag Opt_SuppressTypeApplications setGeneralFlag Opt_SuppressIdInfo setGeneralFlag Opt_SuppressTicks+ setGeneralFlag Opt_SuppressStgFreeVars setGeneralFlag Opt_SuppressTypeSignatures) ------ Debugging ----------------------------------------------------@@ -2979,6 +3087,8 @@ (setDumpFlag Opt_D_dump_stg) , make_ord_flag defGhcFlag "ddump-call-arity" (setDumpFlag Opt_D_dump_call_arity)+ , make_ord_flag defGhcFlag "ddump-exitify"+ (setDumpFlag Opt_D_dump_exitify) , make_ord_flag defGhcFlag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal) , make_ord_flag defGhcFlag "ddump-str-signatures"@@ -3043,6 +3153,8 @@ (setDumpFlag Opt_D_dump_mod_cycles) , make_ord_flag defGhcFlag "ddump-mod-map" (setDumpFlag Opt_D_dump_mod_map)+ , make_ord_flag defGhcFlag "ddump-timings"+ (setDumpFlag Opt_D_dump_timings) , make_ord_flag defGhcFlag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning) , make_ord_flag defGhcFlag "ddump-to-file"@@ -3067,12 +3179,16 @@ (NoArg (setGeneralFlag Opt_D_faststring_stats)) , make_ord_flag defGhcFlag "dno-llvm-mangler" (NoArg (setGeneralFlag Opt_NoLlvmMangler)) -- hidden flag+ , make_ord_flag defGhcFlag "fast-llvm"+ (NoArg (setGeneralFlag Opt_FastLlvm)) -- hidden flag , make_ord_flag defGhcFlag "ddump-debug" (setDumpFlag Opt_D_dump_debug) , make_ord_flag defGhcFlag "ddump-json" (noArg (flip dopt_set Opt_D_dump_json . setJsonLogAction ) ) , make_ord_flag defGhcFlag "dppr-debug" (setDumpFlag Opt_D_ppr_debug)+ , make_ord_flag defGhcFlag "ddebug-output"+ (noArg (flip dopt_unset Opt_D_no_debug_output)) , make_ord_flag defGhcFlag "dno-debug-output" (setDumpFlag Opt_D_no_debug_output) @@ -3088,6 +3204,10 @@ d { sseVersion = Just SSE4 })) , make_ord_flag defGhcFlag "msse4.2" (noArg (\d -> d { sseVersion = Just SSE42 }))+ , make_ord_flag defGhcFlag "mbmi" (noArg (\d ->+ d { bmiVersion = Just BMI1 }))+ , make_ord_flag defGhcFlag "mbmi2" (noArg (\d ->+ d { bmiVersion = Just BMI2 })) , make_ord_flag defGhcFlag "mavx" (noArg (\d -> d { avx = True })) , make_ord_flag defGhcFlag "mavx2" (noArg (\d -> d { avx2 = True })) , make_ord_flag defGhcFlag "mavx512cd" (noArg (\d ->@@ -3109,10 +3229,10 @@ -- Opt_WarnIsError is still needed to pass -Werror -- to CPP; see runCpp in SysTools , make_dep_flag defFlag "Wnot" (NoArg (upd (\d ->- d {warningFlags = IntSet.empty})))+ d {warningFlags = EnumSet.empty}))) "Use -w or -Wno-everything instead" , make_ord_flag defFlag "w" (NoArg (upd (\d ->- d {warningFlags = IntSet.empty})))+ d {warningFlags = EnumSet.empty}))) -- New-style uniform warning sets --@@ -3120,7 +3240,7 @@ , make_ord_flag defFlag "Weverything" (NoArg (mapM_ setWarningFlag minusWeverythingOpts)) , make_ord_flag defFlag "Wno-everything"- (NoArg (upd (\d -> d {warningFlags = IntSet.empty})))+ (NoArg (upd (\d -> d {warningFlags = EnumSet.empty}))) , make_ord_flag defFlag "Wall" (NoArg (mapM_ setWarningFlag minusWallOpts))@@ -3148,7 +3268,6 @@ , make_ord_flag defGhcFlag "ffrontend-opt" (hasArg addFrontendPluginOption) ------ Optimisation flags ------------------------------------------- , make_ord_flag defGhcFlag "O" (noArgM (setOptLevel 1)) , make_dep_flag defGhcFlag "Onot" (noArgM $ setOptLevel 0 ) "Use -O0 instead" , make_ord_flag defGhcFlag "Odph" (noArgM setDPHOpt)@@ -3161,6 +3280,10 @@ (intSuffix (\n d -> d { maxRelevantBinds = Just n })) , make_ord_flag defFlag "fno-max-relevant-binds" (noArg (\d -> d { maxRelevantBinds = Nothing }))+ , make_ord_flag defFlag "fmax-valid-substitutions"+ (intSuffix (\n d -> d { maxValidSubstitutions = Just n }))+ , make_ord_flag defFlag "fno-max-valid-substitutions"+ (noArg (\d -> d { maxValidSubstitutions = Nothing })) , make_ord_flag defFlag "fmax-uncovered-patterns" (intSuffix (\n d -> d { maxUncoveredPatterns = n })) , make_ord_flag defFlag "fsimplifier-phases"@@ -3270,11 +3393,11 @@ , make_ord_flag defGhcFlag "fasm" (NoArg (setObjTarget HscAsm)) , make_ord_flag defGhcFlag "fvia-c" (NoArg- (addWarn $ "The -fvia-c flag does nothing; " ++- "it will be removed in a future GHC release"))+ (deprecate $ "The -fvia-c flag does nothing; " +++ "it will be removed in a future GHC release")) , make_ord_flag defGhcFlag "fvia-C" (NoArg- (addWarn $ "The -fvia-C flag does nothing; " ++- "it will be removed in a future GHC release"))+ (deprecate $ "The -fvia-C flag does nothing; " +++ "it will be removed in a future GHC release")) , make_ord_flag defGhcFlag "fllvm" (NoArg (setObjTarget HscLlvm)) , make_ord_flag defFlag "fno-code" (NoArg ((upd $ \d ->@@ -3350,7 +3473,8 @@ action :: String -> EwM (CmdLineP DynFlags) () action flag = do f <- wopt Opt_WarnUnrecognisedWarningFlags <$> liftEwM getCmdLineState- when f $ addWarn $ "unrecognised warning flag: -" ++ prefix ++ flag+ when f $ addFlagWarn Cmd.ReasonUnrecognisedFlag $+ "unrecognised warning flag: -" ++ prefix ++ flag -- See Note [Supporting CLI completion] package_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]@@ -3525,9 +3649,9 @@ flag | turn_on = lang | otherwise = "No" ++ lang -useInstead :: String -> TurnOnFlag -> String-useInstead flag turn_on- = "Use -f" ++ no ++ flag ++ " instead"+useInstead :: String -> String -> TurnOnFlag -> String+useInstead prefix flag turn_on+ = "Use " ++ prefix ++ no ++ flag ++ " instead" where no = if turn_on then "" else "no-" @@ -3580,6 +3704,7 @@ flagSpec "identities" Opt_WarnIdentities, flagSpec "missing-fields" Opt_WarnMissingFields, flagSpec "missing-import-lists" Opt_WarnMissingImportList,+ flagSpec "missing-export-lists" Opt_WarnMissingExportList, depFlagSpec "missing-local-sigs" Opt_WarnMissingLocalSignatures "it is replaced by -Wmissing-local-signatures", flagSpec "missing-local-signatures" Opt_WarnMissingLocalSignatures,@@ -3632,7 +3757,8 @@ Opt_WarnMissingPatternSynonymSignatures, flagSpec "simplifiable-class-constraints" Opt_WarnSimplifiableClassConstraints, flagSpec "missing-home-modules" Opt_WarnMissingHomeModules,- flagSpec "unrecognised-warning-flags" Opt_WarnUnrecognisedWarningFlags ]+ flagSpec "unrecognised-warning-flags" Opt_WarnUnrecognisedWarningFlags,+ flagSpec "partial-fields" Opt_WarnPartialFields ] -- | These @-\<blah\>@ flags can all be reversed with @-no-\<blah\>@ negatableFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]@@ -3647,8 +3773,9 @@ -- Please keep the list of flags below sorted alphabetically flagSpec "ppr-case-as-let" Opt_PprCaseAsLet, depFlagSpec' "ppr-ticks" Opt_PprShowTicks- (\turn_on -> useInstead "suppress-ticks" (not turn_on)),+ (\turn_on -> useInstead "-d" "suppress-ticks" (not turn_on)), flagSpec "suppress-ticks" Opt_SuppressTicks,+ flagSpec "suppress-stg-free-vars" Opt_SuppressStgFreeVars, flagSpec "suppress-coercions" Opt_SuppressCoercions, flagSpec "suppress-idinfo" Opt_SuppressIdInfo, flagSpec "suppress-unfoldings" Opt_SuppressUnfoldings,@@ -3671,6 +3798,7 @@ flagGhciSpec "break-on-exception" Opt_BreakOnException, flagSpec "building-cabal-package" Opt_BuildingCabalPackage, flagSpec "call-arity" Opt_CallArity,+ flagSpec "exitification" Opt_Exitification, flagSpec "case-merge" Opt_CaseMerge, flagSpec "case-folding" Opt_CaseFolding, flagSpec "cmm-elim-common-blocks" Opt_CmmElimCommonBlocks,@@ -3697,6 +3825,8 @@ flagSpec "flat-cache" Opt_FlatCache, flagSpec "float-in" Opt_FloatIn, flagSpec "force-recomp" Opt_ForceRecomp,+ flagSpec "ignore-optim-changes" Opt_IgnoreOptimChanges,+ flagSpec "ignore-hpc-changes" Opt_IgnoreHpcChanges, flagSpec "full-laziness" Opt_FullLaziness, flagSpec "fun-to-thunk" Opt_FunToThunk, flagSpec "gen-manifest" Opt_GenManifest,@@ -3713,7 +3843,7 @@ flagSpec "kill-one-shot" Opt_KillOneShot, flagSpec "late-dmd-anal" Opt_LateDmdAnal, flagSpec "liberate-case" Opt_LiberateCase,- flagHiddenSpec "llvm-pass-vectors-in-regs" Opt_LlvmPassVectorsInRegisters,+ flagSpec "llvm-pass-vectors-in-regs" Opt_LlvmPassVectorsInRegisters, flagHiddenSpec "llvm-tbaa" Opt_LlvmTBAA, flagHiddenSpec "llvm-fill-undef-with-garbage" Opt_LlvmFillUndefWithGarbage, flagSpec "loopification" Opt_Loopification,@@ -3739,7 +3869,7 @@ flagSpec "regs-graph" Opt_RegsGraph, flagSpec "regs-iterative" Opt_RegsIterative, depFlagSpec' "rewrite-rules" Opt_EnableRewriteRules- (useInstead "enable-rewrite-rules"),+ (useInstead "-f" "enable-rewrite-rules"), flagSpec "shared-implib" Opt_SharedImplib, flagSpec "spec-constr" Opt_SpecConstr, flagSpec "spec-constr-keen" Opt_SpecConstrKeen,@@ -3760,6 +3890,8 @@ flagSpec "version-macros" Opt_VersionMacros, flagSpec "worker-wrapper" Opt_WorkerWrapper, flagSpec "solve-constant-dicts" Opt_SolveConstantDicts,+ flagSpec "catch-bottoms" Opt_CatchBottoms,+ flagSpec "alignment-sanitisation" Opt_AlignmentSanitisation, flagSpec "show-warning-groups" Opt_ShowWarnGroups, flagSpec "hide-source-paths" Opt_HideSourcePaths, flagSpec "show-hole-constraints" Opt_ShowHoleConstraints,@@ -3886,6 +4018,7 @@ flagSpec "DuplicateRecordFields" LangExt.DuplicateRecordFields, flagSpec "EmptyCase" LangExt.EmptyCase, flagSpec "EmptyDataDecls" LangExt.EmptyDataDecls,+ flagSpec "EmptyDataDeriving" LangExt.EmptyDataDeriving, flagSpec "ExistentialQuantification" LangExt.ExistentialQuantification, flagSpec "ExplicitForAll" LangExt.ExplicitForAll, flagSpec "ExplicitNamespaces" LangExt.ExplicitNamespaces,@@ -3926,6 +4059,7 @@ flagSpec "NamedFieldPuns" LangExt.RecordPuns, flagSpec "NamedWildCards" LangExt.NamedWildCards, flagSpec "NegativeLiterals" LangExt.NegativeLiterals,+ flagSpec "HexFloatLiterals" LangExt.HexFloatLiterals, flagSpec "NondecreasingIndentation" LangExt.NondecreasingIndentation, depFlagSpec' "NullaryTypeClasses" LangExt.NullaryTypeClasses (deprecatedForExtension "MultiParamTypeClasses"),@@ -4004,7 +4138,8 @@ Opt_RPath, Opt_SharedImplib, Opt_SimplPreInlining,- Opt_VersionMacros+ Opt_VersionMacros,+ Opt_LlvmPassVectorsInRegisters ] ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]@@ -4101,10 +4236,9 @@ -- If you change the list of flags enabled for particular optimisation levels -- please remember to update the User's Guide. The relevant files are: ----- * utils/mkUserGuidePart/Options/--- * docs/users_guide/using.rst+-- docs/users_guide/using-optimisation.rst ----- The first contains the Flag Refrence section, which breifly lists all+-- The first contains the Flag Reference section, which briefly lists all -- available flags. The second contains a detailed description of the -- flags. Both places should contain information whether a flag is implied by -- -O0, -O or -O2.@@ -4125,6 +4259,7 @@ , ([0], Opt_OmitInterfacePragmas) , ([1,2], Opt_CallArity)+ , ([1,2], Opt_Exitification) , ([1,2], Opt_CaseMerge) , ([1,2], Opt_CaseFolding) , ([1,2], Opt_CmmElimCommonBlocks)@@ -4177,8 +4312,7 @@ -- If you change the list of warning enabled by default -- please remember to update the User's Guide. The relevant file is: ----- * utils/mkUserGuidePart/--- * docs/users_guide/using-warnings.rst+-- docs/users_guide/using-warnings.rst -- | Warning groups. --@@ -4320,6 +4454,7 @@ disableGlasgowExts = do unSetGeneralFlag Opt_PrintExplicitForalls mapM_ unSetExtensionFlag glasgowExtsFlags +-- Please keep what_glasgow_exts_does.rst up to date with this list glasgowExtsFlags :: [LangExt.Extension] glasgowExtsFlags = [ LangExt.ConstrainedClassMethods@@ -4891,7 +5026,7 @@ addFrameworkPath p = upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p}) -#ifndef mingw32_TARGET_OS+#if !defined(mingw32_TARGET_OS) split_marker :: Char split_marker = ':' -- not configurable (ToDo) #endif@@ -4903,7 +5038,7 @@ -- cause confusion when they are translated into -I options -- for passing to gcc. where-#ifndef mingw32_TARGET_OS+#if !defined(mingw32_TARGET_OS) splitUp xs = split split_marker xs #else -- Windows: 'hybrid' support for DOS-style paths in directory lists.@@ -5054,7 +5189,7 @@ -- Next come the settings, so anything else can be overridden -- in the settings file (as "lookup" uses the first match for the -- key)- : rawSettings dflags+ : map (fmap $ expandTopDir $ topDir dflags) (rawSettings dflags) ++ [("Project version", projectVersion dflags), ("Project Git commit id", cProjectGitCommitId), ("Booter version", cBooterVersion),@@ -5244,9 +5379,10 @@ -- initialized. defaultGlobalDynFlags :: DynFlags defaultGlobalDynFlags =- (defaultDynFlags settings) { verbosity = 2 }+ (defaultDynFlags settings llvmTargets) { verbosity = 2 } where- settings = panic "v_unsafeGlobalDynFlags: not initialised"+ settings = panic "v_unsafeGlobalDynFlags: settings not initialised"+ llvmTargets = panic "v_unsafeGlobalDynFlags: llvmTargets not initialised" #if STAGE < 2 GLOBAL_VAR(v_unsafeGlobalDynFlags, defaultGlobalDynFlags, DynFlags)@@ -5317,12 +5453,32 @@ isAvx512pfEnabled dflags = avx512pf dflags -- -----------------------------------------------------------------------------+-- BMI2++data BmiVersion = BMI1+ | BMI2+ deriving (Eq, Ord)++isBmiEnabled :: DynFlags -> Bool+isBmiEnabled dflags = case platformArch (targetPlatform dflags) of+ ArchX86_64 -> bmiVersion dflags >= Just BMI1+ ArchX86 -> bmiVersion dflags >= Just BMI1+ _ -> False++isBmi2Enabled :: DynFlags -> Bool+isBmi2Enabled dflags = case platformArch (targetPlatform dflags) of+ ArchX86_64 -> bmiVersion dflags >= Just BMI2+ ArchX86 -> bmiVersion dflags >= Just BMI2+ _ -> False++-- ----------------------------------------------------------------------------- -- Linker/compiler information -- LinkerInfo contains any extra options needed by the system linker. data LinkerInfo = GnuLD [Option] | GnuGold [Option]+ | LlvmLLD [Option] | DarwinLD [Option] | SolarisLD [Option] | AixLD [Option]@@ -5355,3 +5511,24 @@ foreign import ccall unsafe "setHeapSize" setHeapSize :: Int -> IO () foreign import ccall unsafe "enableTimingStats" enableTimingStats :: IO ()++-- -----------------------------------------------------------------------------+-- Types for managing temporary files.+--+-- these are here because FilesToClean is used in DynFlags++-- | A collection of files that must be deleted before ghc exits.+-- The current collection+-- is stored in an IORef in DynFlags, 'filesToClean'.+data FilesToClean = FilesToClean {+ ftcGhcSession :: !(Set FilePath),+ -- ^ Files that will be deleted at the end of runGhc(T)+ ftcCurrentModule :: !(Set FilePath)+ -- ^ Files that will be deleted the next time+ -- 'FileCleanup.cleanCurrentModuleTempFiles' is called, or otherwise at the+ -- end of the session.+ }++-- | An empty FilesToClean+emptyFilesToClean :: FilesToClean+emptyFilesToClean = FilesToClean Set.empty Set.empty
main/DynFlags.hs-boot view
@@ -1,6 +1,6 @@- module DynFlags where +import GhcPrelude import Platform data DynFlags
main/DynamicLoading.hs view
@@ -2,7 +2,7 @@ -- | Dynamically lookup up values from modules and loading them. module DynamicLoading (-#ifdef GHCI+#if defined(GHCI) -- * Loading plugins loadPlugins, loadFrontendPlugin,@@ -24,7 +24,9 @@ #endif ) where -#ifdef GHCI+import GhcPrelude++#if defined(GHCI) import Linker ( linkModule, getHValue ) import GHCi ( wormhole ) import SrcLoc ( noSrcSpan )@@ -66,7 +68,7 @@ #endif -#ifdef GHCI+#if defined(GHCI) loadPlugins :: HscEnv -> IO [(ModuleName, Plugin, [CommandLineOption])] loadPlugins hsc_env
main/Elf.hs view
@@ -14,9 +14,11 @@ makeElfNote ) where +import GhcPrelude++import AsmUtils import Exception import DynFlags-import Platform import ErrUtils import Maybes (MaybeT(..),runMaybeT) import Util (charToC)@@ -415,12 +417,12 @@ -- If we add new target platforms, we need to check that the generated words -- are 32-bit long, otherwise we need to use platform specific directives to -- force 32-bit .int in asWord32.-makeElfNote :: DynFlags -> String -> String -> Word32 -> String -> SDoc-makeElfNote dflags sectionName noteName typ contents = hcat [+makeElfNote :: String -> String -> Word32 -> String -> SDoc+makeElfNote sectionName noteName typ contents = hcat [ text "\t.section ", text sectionName, text ",\"\",",- text elfSectionNote,+ sectionType "note", text "\n", -- note name length (+ 1 for ending \0)@@ -452,12 +454,6 @@ text "\t.int ", text (show x), text "\n"]-- elfSectionNote :: String- elfSectionNote = case platformArch (targetPlatform dflags) of- ArchARM _ _ _ -> "%note"- _ -> "@note"- ------------------
main/ErrUtils.hs view
@@ -10,11 +10,11 @@ module ErrUtils ( -- * Basic types- Validity(..), andValid, allValid, isValid, getInvalids,+ Validity(..), andValid, allValid, isValid, getInvalids, orValid, Severity(..), -- * Messages- ErrMsg, errMsgDoc,+ ErrMsg, errMsgDoc, errMsgSeverity, errMsgReason, ErrDoc, errDoc, errDocImportant, errDocContext, errDocSupplementary, WarnMsg, MsgDoc, Messages, ErrorMessages, WarningMessages,@@ -32,7 +32,7 @@ emptyMessages, mkLocMessage, mkLocMessageAnn, makeIntoWarning, mkErrMsg, mkPlainErrMsg, mkErrDoc, mkLongErrMsg, mkWarnMsg, mkPlainWarnMsg,- warnIsErrorMsg, mkLongWarnMsg,+ mkLongWarnMsg, -- * Utilities doIfSet, doIfSet_dyn,@@ -52,10 +52,13 @@ debugTraceMsg, ghcExit, prettyPrintGhcErrors,+ traceCmd ) where #include "HsVersions.h" +import GhcPrelude+ import Bag import Exception import Outputable@@ -107,6 +110,10 @@ getInvalids :: [Validity] -> [MsgDoc] getInvalids vs = [d | NotValid d <- vs] +orValid :: Validity -> Validity -> Validity+orValid IsValid _ = IsValid+orValid _ v = v+ -- ----------------------------------------------------------------------------- -- Basic error messages: just render a message with a source location. @@ -153,7 +160,7 @@ | SevInteractive | SevDump- -- ^ Log messagse intended for compiler developers+ -- ^ Log message intended for compiler developers -- No file/line/column stuff | SevInfo@@ -348,10 +355,6 @@ isEmptyMessages :: Messages -> Bool isEmptyMessages (warns, errs) = isEmptyBag warns && isEmptyBag errs -warnIsErrorMsg :: DynFlags -> ErrMsg-warnIsErrorMsg dflags- = mkPlainErrMsg dflags noSrcSpan (text "\nFailing due to -Werror.")- errorsFound :: DynFlags -> Messages -> Bool errorsFound _dflags (_warns, errs) = not (isEmptyBag errs) @@ -453,7 +456,30 @@ where line = text (replicate 20 '=') +-- | Run an action with the handle of a 'DumpFlag' if we are outputting to a+-- file, otherwise 'Nothing'.+withDumpFileHandle :: DynFlags -> DumpFlag -> (Maybe Handle -> IO ()) -> IO ()+withDumpFileHandle dflags flag action = do+ let mFile = chooseDumpFile dflags flag+ case mFile of+ Just fileName -> do+ let gdref = generatedDumps dflags+ gd <- readIORef gdref+ let append = Set.member fileName gd+ mode = if append then AppendMode else WriteMode+ unless append $+ writeIORef gdref (Set.insert fileName gd)+ createDirectoryIfMissing True (takeDirectory fileName)+ withFile fileName mode $ \handle -> do+ -- We do not want the dump file to be affected by+ -- environment variables, but instead to always use+ -- UTF8. See:+ -- https://ghc.haskell.org/trac/ghc/ticket/10762+ hSetEncoding handle utf8 + action (Just handle)+ Nothing -> action Nothing+ -- | Write out a dump. -- If --dump-to-file is set then this goes to a file. -- otherwise emit to stdout.@@ -464,43 +490,28 @@ -- The 'DumpFlag' is used only to choose the filename to use if @--dump-to-file@ -- is used; it is not used to decide whether to dump the output dumpSDoc :: DynFlags -> PrintUnqualified -> DumpFlag -> String -> SDoc -> IO ()-dumpSDoc dflags print_unqual flag hdr doc- = do let mFile = chooseDumpFile dflags flag- dump_style = mkDumpStyle dflags print_unqual- case mFile of- Just fileName- -> do- let gdref = generatedDumps dflags- gd <- readIORef gdref- let append = Set.member fileName gd- mode = if append then AppendMode else WriteMode- unless append $- writeIORef gdref (Set.insert fileName gd)- createDirectoryIfMissing True (takeDirectory fileName)- handle <- openFile fileName mode-- -- We do not want the dump file to be affected by- -- environment variables, but instead to always use- -- UTF8. See:- -- https://ghc.haskell.org/trac/ghc/ticket/10762- hSetEncoding handle utf8+dumpSDoc dflags print_unqual flag hdr doc =+ withDumpFileHandle dflags flag writeDump+ where+ dump_style = mkDumpStyle dflags print_unqual - doc' <- if null hdr- then return doc- else do t <- getCurrentTime- let d = text (show t)- $$ blankLine- $$ doc- return $ mkDumpDoc hdr d- defaultLogActionHPrintDoc dflags handle doc' dump_style- hClose handle+ -- write dump to file+ writeDump (Just handle) = do+ doc' <- if null hdr+ then return doc+ else do t <- getCurrentTime+ let d = text (show t)+ $$ blankLine+ $$ doc+ return $ mkDumpDoc hdr d+ defaultLogActionHPrintDoc dflags handle doc' dump_style - -- write the dump to stdout- Nothing -> do- let (doc', severity)- | null hdr = (doc, SevOutput)- | otherwise = (mkDumpDoc hdr doc, SevDump)- putLogMsg dflags NoReason severity noSrcSpan dump_style doc'+ -- write the dump to stdout+ writeDump Nothing = do+ let (doc', severity)+ | null hdr = (doc, SevOutput)+ | otherwise = (mkDumpDoc hdr doc, SevDump)+ putLogMsg dflags NoReason severity noSrcSpan dump_style doc' -- | Choose where to put a dump file based on DynFlags@@ -611,7 +622,7 @@ -> m a withTiming getDFlags what force_result action = do dflags <- getDFlags- if verbosity dflags >= 2+ if verbosity dflags >= 2 || dopt Opt_D_dump_timings dflags then do liftIO $ logInfo dflags (defaultUserStyle dflags) $ text "***" <+> what <> colon alloc0 <- liftIO getAllocationCounter@@ -622,14 +633,24 @@ alloc1 <- liftIO getAllocationCounter -- recall that allocation counter counts down let alloc = alloc0 - alloc1- liftIO $ logInfo dflags (defaultUserStyle dflags)- (text "!!!" <+> what <> colon <+> text "finished in"- <+> doublePrec 2 (realToFrac (end - start) * 1e-9)- <+> text "milliseconds"- <> comma- <+> text "allocated"- <+> doublePrec 3 (realToFrac alloc / 1024 / 1024)- <+> text "megabytes")+ time = realToFrac (end - start) * 1e-9++ when (verbosity dflags >= 2)+ $ liftIO $ logInfo dflags (defaultUserStyle dflags)+ (text "!!!" <+> what <> colon <+> text "finished in"+ <+> doublePrec 2 time+ <+> text "milliseconds"+ <> comma+ <+> text "allocated"+ <+> doublePrec 3 (realToFrac alloc / 1024 / 1024)+ <+> text "megabytes")++ liftIO $ dumpIfSet_dyn dflags Opt_D_dump_timings ""+ $ text $ showSDocOneLine dflags+ $ hsep [ what <> colon+ , text "alloc=" <> ppr alloc+ , text "time=" <> doublePrec 3 time+ ] pure r else action @@ -669,7 +690,32 @@ liftIO $ throwIO e -- | Checks if given 'WarnMsg' is a fatal warning.-isWarnMsgFatal :: DynFlags -> WarnMsg -> Bool+isWarnMsgFatal :: DynFlags -> WarnMsg -> Maybe (Maybe WarningFlag) isWarnMsgFatal dflags ErrMsg{errMsgReason = Reason wflag}- = wopt_fatal wflag dflags-isWarnMsgFatal dflags _ = gopt Opt_WarnIsError dflags+ = if wopt_fatal wflag dflags+ then Just (Just wflag)+ else Nothing+isWarnMsgFatal dflags _+ = if gopt Opt_WarnIsError dflags+ then Just Nothing+ else Nothing++traceCmd :: DynFlags -> String -> String -> IO a -> IO a+-- trace the command (at two levels of verbosity)+traceCmd dflags phase_name cmd_line action+ = do { let verb = verbosity dflags+ ; showPass dflags phase_name+ ; debugTraceMsg dflags 3 (text cmd_line)+ ; case flushErr dflags of+ FlushErr io -> io++ -- And run it!+ ; action `catchIO` handle_exn verb+ }+ where+ handle_exn _verb exn = do { debugTraceMsg dflags 2 (char '\n')+ ; debugTraceMsg dflags 2+ (text "Failed:"+ <+> text cmd_line+ <+> text (show exn))+ ; throwGhcExceptionIO (ProgramError (show exn))}
main/ErrUtils.hs-boot view
@@ -1,5 +1,6 @@ module ErrUtils where +import GhcPrelude import Outputable (SDoc, PrintUnqualified ) import SrcLoc (SrcSpan) import Json
+ main/FileCleanup.hs view
@@ -0,0 +1,299 @@+{-# LANGUAGE CPP #-}+module FileCleanup+ ( TempFileLifetime(..)+ , cleanTempDirs, cleanTempFiles, cleanCurrentModuleTempFiles+ , addFilesToClean, changeTempFilesLifetime+ , newTempName, newTempLibName+ , withSystemTempDirectory, withTempDirectory+ ) where++import GhcPrelude++import DynFlags+import ErrUtils+import Outputable+import Util+import Exception+import DriverPhases++import Control.Monad+import Data.List+import qualified Data.Set as Set+import qualified Data.Map as Map+import Data.IORef+import System.Directory+import System.FilePath+import System.IO.Error++#if !defined(mingw32_HOST_OS)+import qualified System.Posix.Internals+#endif++-- | Used when a temp file is created. This determines which component Set of+-- FilesToClean will get the temp file+data TempFileLifetime+ = TFL_CurrentModule+ -- ^ A file with lifetime TFL_CurrentModule will be cleaned up at the+ -- end of upweep_mod+ | TFL_GhcSession+ -- ^ A file with lifetime TFL_GhcSession will be cleaned up at the end of+ -- runGhc(T)+ deriving (Show)++cleanTempDirs :: DynFlags -> IO ()+cleanTempDirs dflags+ = unless (gopt Opt_KeepTmpFiles dflags)+ $ mask_+ $ do let ref = dirsToClean dflags+ ds <- atomicModifyIORef' ref $ \ds -> (Map.empty, ds)+ removeTmpDirs dflags (Map.elems ds)++-- | Delete all files in @filesToClean dflags@.+cleanTempFiles :: DynFlags -> IO ()+cleanTempFiles dflags+ = unless (gopt Opt_KeepTmpFiles dflags)+ $ mask_+ $ do let ref = filesToClean dflags+ to_delete <- atomicModifyIORef' ref $+ \FilesToClean+ { ftcCurrentModule = cm_files+ , ftcGhcSession = gs_files+ } -> ( emptyFilesToClean+ , Set.toList cm_files ++ Set.toList gs_files)+ removeTmpFiles dflags to_delete++-- | Delete all files in @filesToClean dflags@. That have lifetime+-- TFL_CurrentModule.+-- If a file must be cleaned eventually, but must survive a+-- cleanCurrentModuleTempFiles, ensure it has lifetime TFL_GhcSession.+cleanCurrentModuleTempFiles :: DynFlags -> IO ()+cleanCurrentModuleTempFiles dflags+ = unless (gopt Opt_KeepTmpFiles dflags)+ $ mask_+ $ do let ref = filesToClean dflags+ to_delete <- atomicModifyIORef' ref $+ \ftc@FilesToClean{ftcCurrentModule = cm_files} ->+ (ftc {ftcCurrentModule = Set.empty}, Set.toList cm_files)+ removeTmpFiles dflags to_delete++-- | Ensure that new_files are cleaned on the next call of+-- 'cleanTempFiles' or 'cleanCurrentModuleTempFiles', depending on lifetime.+-- If any of new_files are already tracked, they will have their lifetime+-- updated.+addFilesToClean :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()+addFilesToClean dflags lifetime new_files = modifyIORef' (filesToClean dflags) $+ \FilesToClean+ { ftcCurrentModule = cm_files+ , ftcGhcSession = gs_files+ } -> case lifetime of+ TFL_CurrentModule -> FilesToClean+ { ftcCurrentModule = cm_files `Set.union` new_files_set+ , ftcGhcSession = gs_files `Set.difference` new_files_set+ }+ TFL_GhcSession -> FilesToClean+ { ftcCurrentModule = cm_files `Set.difference` new_files_set+ , ftcGhcSession = gs_files `Set.union` new_files_set+ }+ where+ new_files_set = Set.fromList new_files++-- | Update the lifetime of files already being tracked. If any files are+-- not being tracked they will be discarded.+changeTempFilesLifetime :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()+changeTempFilesLifetime dflags lifetime files = do+ FilesToClean+ { ftcCurrentModule = cm_files+ , ftcGhcSession = gs_files+ } <- readIORef (filesToClean dflags)+ let old_set = case lifetime of+ TFL_CurrentModule -> gs_files+ TFL_GhcSession -> cm_files+ existing_files = [f | f <- files, f `Set.member` old_set]+ addFilesToClean dflags lifetime existing_files++-- Return a unique numeric temp file suffix+newTempSuffix :: DynFlags -> IO Int+newTempSuffix dflags =+ atomicModifyIORef' (nextTempSuffix dflags) $ \n -> (n+1,n)++-- Find a temporary name that doesn't already exist.+newTempName :: DynFlags -> TempFileLifetime -> Suffix -> IO FilePath+newTempName dflags lifetime extn+ = do d <- getTempDir dflags+ findTempName (d </> "ghc_") -- See Note [Deterministic base name]+ where+ findTempName :: FilePath -> IO FilePath+ findTempName prefix+ = do n <- newTempSuffix dflags+ let filename = prefix ++ show n <.> extn+ b <- doesFileExist filename+ if b then findTempName prefix+ else do -- clean it up later+ addFilesToClean dflags lifetime [filename]+ return filename++newTempLibName :: DynFlags -> TempFileLifetime -> Suffix+ -> IO (FilePath, FilePath, String)+newTempLibName dflags lifetime extn+ = do d <- getTempDir dflags+ findTempName d ("ghc_")+ where+ findTempName :: FilePath -> String -> IO (FilePath, FilePath, String)+ findTempName dir prefix+ = do n <- newTempSuffix dflags -- See Note [Deterministic base name]+ let libname = prefix ++ show n+ filename = dir </> "lib" ++ libname <.> extn+ b <- doesFileExist filename+ if b then findTempName dir prefix+ else do -- clean it up later+ addFilesToClean dflags lifetime [filename]+ return (filename, dir, libname)+++-- Return our temporary directory within tmp_dir, creating one if we+-- don't have one yet.+getTempDir :: DynFlags -> IO FilePath+getTempDir dflags = do+ mapping <- readIORef dir_ref+ case Map.lookup tmp_dir mapping of+ Nothing -> do+ pid <- getProcessID+ let prefix = tmp_dir </> "ghc" ++ show pid ++ "_"+ mask_ $ mkTempDir prefix+ Just dir -> return dir+ where+ tmp_dir = tmpDir dflags+ dir_ref = dirsToClean dflags++ mkTempDir :: FilePath -> IO FilePath+ mkTempDir prefix = do+ n <- newTempSuffix dflags+ let our_dir = prefix ++ show n++ -- 1. Speculatively create our new directory.+ createDirectory our_dir++ -- 2. Update the dirsToClean mapping unless an entry already exists+ -- (i.e. unless another thread beat us to it).+ their_dir <- atomicModifyIORef' dir_ref $ \mapping ->+ case Map.lookup tmp_dir mapping of+ Just dir -> (mapping, Just dir)+ Nothing -> (Map.insert tmp_dir our_dir mapping, Nothing)++ -- 3. If there was an existing entry, return it and delete the+ -- directory we created. Otherwise return the directory we created.+ case their_dir of+ Nothing -> do+ debugTraceMsg dflags 2 $+ text "Created temporary directory:" <+> text our_dir+ return our_dir+ Just dir -> do+ removeDirectory our_dir+ return dir+ `catchIO` \e -> if isAlreadyExistsError e+ then mkTempDir prefix else ioError e++{- Note [Deterministic base name]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++The filename of temporary files, especially the basename of C files, can end+up in the output in some form, e.g. as part of linker debug information. In the+interest of bit-wise exactly reproducible compilation (#4012), the basename of+the temporary file no longer contains random information (it used to contain+the process id).++This is ok, as the temporary directory used contains the pid (see getTempDir).+-}+removeTmpDirs :: DynFlags -> [FilePath] -> IO ()+removeTmpDirs dflags ds+ = traceCmd dflags "Deleting temp dirs"+ ("Deleting: " ++ unwords ds)+ (mapM_ (removeWith dflags removeDirectory) ds)++removeTmpFiles :: DynFlags -> [FilePath] -> IO ()+removeTmpFiles dflags fs+ = warnNon $+ traceCmd dflags "Deleting temp files"+ ("Deleting: " ++ unwords deletees)+ (mapM_ (removeWith dflags removeFile) deletees)+ where+ -- Flat out refuse to delete files that are likely to be source input+ -- files (is there a worse bug than having a compiler delete your source+ -- files?)+ --+ -- Deleting source files is a sign of a bug elsewhere, so prominently flag+ -- the condition.+ warnNon act+ | null non_deletees = act+ | otherwise = do+ putMsg dflags (text "WARNING - NOT deleting source files:"+ <+> hsep (map text non_deletees))+ act++ (non_deletees, deletees) = partition isHaskellUserSrcFilename fs++removeWith :: DynFlags -> (FilePath -> IO ()) -> FilePath -> IO ()+removeWith dflags remover f = remover f `catchIO`+ (\e ->+ let msg = if isDoesNotExistError e+ then text "Warning: deleting non-existent" <+> text f+ else text "Warning: exception raised when deleting"+ <+> text f <> colon+ $$ text (show e)+ in debugTraceMsg dflags 2 msg+ )++#if defined(mingw32_HOST_OS)+-- relies on Int == Int32 on Windows+foreign import ccall unsafe "_getpid" getProcessID :: IO Int+#else+getProcessID :: IO Int+getProcessID = System.Posix.Internals.c_getpid >>= return . fromIntegral+#endif++-- The following three functions are from the `temporary` package.++-- | Create and use a temporary directory in the system standard temporary+-- directory.+--+-- Behaves exactly the same as 'withTempDirectory', except that the parent+-- temporary directory will be that returned by 'getTemporaryDirectory'.+withSystemTempDirectory :: String -- ^ Directory name template. See 'openTempFile'.+ -> (FilePath -> IO a) -- ^ Callback that can use the directory+ -> IO a+withSystemTempDirectory template action =+ getTemporaryDirectory >>= \tmpDir -> withTempDirectory tmpDir template action+++-- | Create and use a temporary directory.+--+-- Creates a new temporary directory inside the given directory, making use+-- of the template. The temp directory is deleted after use. For example:+--+-- > withTempDirectory "src" "sdist." $ \tmpDir -> do ...+--+-- The @tmpDir@ will be a new subdirectory of the given directory, e.g.+-- @src/sdist.342@.+withTempDirectory :: FilePath -- ^ Temp directory to create the directory in+ -> String -- ^ Directory name template. See 'openTempFile'.+ -> (FilePath -> IO a) -- ^ Callback that can use the directory+ -> IO a+withTempDirectory targetDir template =+ Exception.bracket+ (createTempDirectory targetDir template)+ (ignoringIOErrors . removeDirectoryRecursive)++ignoringIOErrors :: IO () -> IO ()+ignoringIOErrors ioe = ioe `catch` (\e -> const (return ()) (e :: IOError))+++createTempDirectory :: FilePath -> String -> IO FilePath+createTempDirectory dir template = do+ pid <- getProcessID+ findTempName pid+ where findTempName x = do+ let path = dir </> template ++ show x+ createDirectory path+ return path+ `catchIO` \e -> if isAlreadyExistsError e+ then findTempName (x+1) else ioError e
main/Finder.hs view
@@ -33,6 +33,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Module import HscTypes import Packages
main/GHC.hs view
@@ -1,5 +1,5 @@-{-# LANGUAGE CPP, NondecreasingIndentation, ScopedTypeVariables,- NamedFieldPuns, TupleSections #-}+{-# LANGUAGE CPP, NondecreasingIndentation, ScopedTypeVariables #-}+{-# LANGUAGE TupleSections, NamedFieldPuns #-} -- ----------------------------------------------------------------------------- --@@ -23,7 +23,7 @@ gcatch, gbracket, gfinally, printException, handleSourceError,- needsTemplateHaskell,+ needsTemplateHaskellOrQQ, -- * Flags and settings DynFlags(..), GeneralFlag(..), Severity(..), HscTarget(..), gopt,@@ -59,7 +59,9 @@ compileToCoreModule, compileToCoreSimplified, -- * Inspecting the module structure of the program- ModuleGraph, ModSummary(..), ms_mod_name, ModLocation(..),+ ModuleGraph, emptyMG, mapMG, mkModuleGraph, mgModSummaries,+ mgLookupModule,+ ModSummary(..), ms_mod_name, ModLocation(..), getModSummary, getModuleGraph, isLoaded,@@ -281,6 +283,8 @@ #include "HsVersions.h" +import GhcPrelude hiding (init)+ import ByteCodeTypes import InteractiveEval import InteractiveEvalTypes@@ -316,7 +320,8 @@ import DriverPhases ( Phase(..), isHaskellSrcFilename ) import Finder import HscTypes-import DynFlags+import CmdLineParser+import DynFlags hiding (WarnReason(..)) import SysTools import Annotations import Module@@ -341,6 +346,7 @@ import TcRnDriver import Inst import FamInst+import FileCleanup import Data.Foldable import qualified Data.Map.Strict as Map@@ -357,8 +363,6 @@ import Exception import Data.IORef import System.FilePath-import System.IO-import Prelude hiding (init) -- %************************************************************************@@ -489,7 +493,8 @@ initGhcMonad mb_top_dir = do { env <- liftIO $ do { mySettings <- initSysTools mb_top_dir- ; dflags <- initDynFlags (defaultDynFlags mySettings)+ ; myLlvmTargets <- initLlvmTargets mb_top_dir+ ; dflags <- initDynFlags (defaultDynFlags mySettings myLlvmTargets) ; checkBrokenTablesNextToCode dflags ; setUnsafeGlobalDynFlags dflags -- c.f. DynFlags.parseDynamicFlagsFull, which@@ -628,7 +633,7 @@ -- invalidateModSummaryCache :: GhcMonad m => m () invalidateModSummaryCache =- modifySession $ \h -> h { hsc_mod_graph = map inval (hsc_mod_graph h) }+ modifySession $ \h -> h { hsc_mod_graph = mapMG inval (hsc_mod_graph h) } where inval ms = ms { ms_hs_date = addUTCTime (-1) (ms_hs_date ms) } @@ -653,7 +658,7 @@ parseDynamicFlags :: MonadIO m => DynFlags -> [Located String]- -> m (DynFlags, [Located String], [Located String])+ -> m (DynFlags, [Located String], [Warn]) parseDynamicFlags = parseDynamicFlagsCmdLine -- | Checks the set of new DynFlags for possibly erroneous option@@ -663,7 +668,7 @@ checkNewDynFlags dflags = do -- See Note [DynFlags consistency] let (dflags', warnings) = makeDynFlagsConsistent dflags- liftIO $ handleFlagWarnings dflags warnings+ liftIO $ handleFlagWarnings dflags (map (Warn NoReason) warnings) return dflags' checkNewInteractiveDynFlags :: MonadIO m => DynFlags -> m DynFlags@@ -842,10 +847,10 @@ instance DesugaredMod DesugaredModule where coreModule m = dm_core_module m -type ParsedSource = Located (HsModule RdrName)-type RenamedSource = (HsGroup Name, [LImportDecl Name], Maybe [LIE Name],+type ParsedSource = Located (HsModule GhcPs)+type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe LHsDocString)-type TypecheckedSource = LHsBinds Id+type TypecheckedSource = LHsBinds GhcTc -- NOTE: -- - things that aren't in the output of the typechecker right now:@@ -870,7 +875,10 @@ getModSummary :: GhcMonad m => ModuleName -> m ModSummary getModSummary mod = do mg <- liftM hsc_mod_graph getSession- case [ ms | ms <- mg, ms_mod_name ms == mod, not (isBootSummary ms) ] of+ let mods_by_name = [ ms | ms <- mgModSummaries mg+ , ms_mod_name ms == mod+ , not (isBootSummary ms) ]+ case mods_by_name of [] -> do dflags <- getDynFlags liftIO $ throwIO $ mkApiErr dflags (text "Module not part of module graph") [ms] -> return ms@@ -1020,20 +1028,23 @@ _ <- load LoadAllTargets -- Then find dependencies modGraph <- depanal [] True- case find ((== fn) . msHsFilePath) modGraph of+ case find ((== fn) . msHsFilePath) (mgModSummaries modGraph) of Just modSummary -> do -- Now we have the module name; -- parse, typecheck and desugar the module- mod_guts <- coreModule `fmap`- -- TODO: space leaky: call hsc* directly?- (desugarModule =<< typecheckModule =<< parseModule modSummary)+ (tcg, mod_guts) <- -- TODO: space leaky: call hsc* directly?+ do tm <- typecheckModule =<< parseModule modSummary+ let tcg = fst (tm_internals tm)+ (,) tcg . coreModule <$> desugarModule tm liftM (gutsToCoreModule (mg_safe_haskell mod_guts)) $ if simplify then do -- If simplify is true: simplify (hscSimplify), then tidy -- (tidyProgram). hsc_env <- getSession- simpl_guts <- liftIO $ hscSimplify hsc_env mod_guts+ simpl_guts <- liftIO $ do+ plugins <- readIORef (tcg_th_coreplugins tcg)+ hscSimplify hsc_env plugins mod_guts tidy_guts <- liftIO $ tidyProgram hsc_env simpl_guts return $ Left tidy_guts else@@ -1072,15 +1083,6 @@ getModuleGraph :: GhcMonad m => m ModuleGraph -- ToDo: DiGraph ModSummary getModuleGraph = liftM hsc_mod_graph getSession --- | Determines whether a set of modules requires Template Haskell.------ Note that if the session's 'DynFlags' enabled Template Haskell when--- 'depanal' was called, then each module in the returned module graph will--- have Template Haskell enabled whether it is actually needed or not.-needsTemplateHaskell :: ModuleGraph -> Bool-needsTemplateHaskell ms =- any (xopt LangExt.TemplateHaskell . ms_hspp_opts) ms- -- | Return @True@ <==> module is loaded. isLoaded :: GhcMonad m => ModuleName -> m Bool isLoaded m = withSession $ \hsc_env ->@@ -1117,7 +1119,7 @@ getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo) -- XXX: Maybe X getModuleInfo mdl = withSession $ \hsc_env -> do let mg = hsc_mod_graph hsc_env- if mdl `elem` map ms_mod mg+ if mgElemModule mg mdl then liftIO $ getHomeModuleInfo hsc_env mdl else do {- if isHomeModule (hsc_dflags hsc_env) mdl@@ -1242,12 +1244,15 @@ -- by 'Name'. Each name's lists will contain every instance in which that name -- is mentioned in the instance head. getNameToInstancesIndex :: GhcMonad m- => m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))-getNameToInstancesIndex = do+ => [Module] -- ^ visible modules. An orphan instance will be returned if and+ -- only it is visible from at least one module in the list.+ -> m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))+getNameToInstancesIndex visible_mods = do hsc_env <- getSession liftIO $ runTcInteractive hsc_env $ do { loadUnqualIfaces hsc_env (hsc_IC hsc_env)- ; InstEnvs {ie_global, ie_local, ie_visible} <- tcGetInstEnvs+ ; InstEnvs {ie_global, ie_local} <- tcGetInstEnvs+ ; let visible_mods' = mkModuleSet visible_mods ; (pkg_fie, home_fie) <- tcGetFamInstEnvs -- We use Data.Sequence.Seq because we are creating left associated -- mappends.@@ -1255,7 +1260,7 @@ ; let cls_index = Map.fromListWith mappend [ (n, Seq.singleton ispec) | ispec <- instEnvElts ie_local ++ instEnvElts ie_global- , instIsVisible ie_visible ispec+ , instIsVisible visible_mods' ispec , n <- nameSetElemsStable $ orphNamesOfClsInst ispec ] ; let fam_index = Map.fromListWith mappend@@ -1303,7 +1308,6 @@ -- ---------------------------------------------------------------------------- -#if 0 -- ToDo: -- - Data and Typeable instances for HsSyn.@@ -1317,7 +1321,6 @@ -- :browse will use either lm_toplev or inspect lm_interface, depending -- on whether the module is interpreted or not. -#endif -- Extract the filename, stringbuffer content and dynflags associed to a module --@@ -1343,7 +1346,7 @@ let startLoc = mkRealSrcLoc (mkFastString sourceFile) 1 1 case lexTokenStream source startLoc flags of POk _ ts -> return ts- PFailed span err ->+ PFailed _ span err -> do dflags <- getDynFlags liftIO $ throwIO $ mkSrcErr (unitBag $ mkPlainErrMsg dflags span err) @@ -1356,7 +1359,7 @@ let startLoc = mkRealSrcLoc (mkFastString sourceFile) 1 1 case lexTokenStream source startLoc flags of POk _ ts -> return $ addSourceToTokens startLoc source ts- PFailed span err ->+ PFailed _ span err -> do dflags <- getDynFlags liftIO $ throwIO $ mkSrcErr (unitBag $ mkPlainErrMsg dflags span err) @@ -1524,7 +1527,7 @@ parser :: String -- ^ Haskell module source text (full Unicode is supported) -> DynFlags -- ^ the flags -> FilePath -- ^ the filename (for source locations)- -> Either ErrorMessages (WarningMessages, Located (HsModule RdrName))+ -> (WarningMessages, Either ErrorMessages (Located (HsModule GhcPs))) parser str dflags filename = let@@ -1533,9 +1536,10 @@ in case unP Parser.parseModule (mkPState dflags buf loc) of - PFailed span err ->- Left (unitBag (mkPlainErrMsg dflags span err))+ PFailed warnFn span err ->+ let (warns,_) = warnFn dflags in+ (warns, Left $ unitBag (mkPlainErrMsg dflags span err)) POk pst rdr_module -> let (warns,_) = getMessages pst dflags in- Right (warns, rdr_module)+ (warns, Right rdr_module)
main/GhcMake.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE BangPatterns, CPP, NondecreasingIndentation, ScopedTypeVariables #-}+{-# LANGUAGE NamedFieldPuns #-} {-# OPTIONS_GHC -fno-warn-warnings-deprecations #-} -- NB: we specifically ignore deprecations. GHC 7.6 marks the .QSem module as -- deprecated, although it became un-deprecated later. As a result, using 7.6@@ -32,6 +33,8 @@ #include "HsVersions.h" +import GhcPrelude+ import qualified Linker ( unload ) import DriverPhases@@ -59,7 +62,6 @@ import Panic import SrcLoc import StringBuffer-import SysTools import UniqFM import UniqDSet import TcBackpack@@ -68,6 +70,7 @@ import Util import qualified GHC.LanguageExtensions as LangExt import NameEnv+import FileCleanup import Data.Either ( rights, partitionEithers ) import qualified Data.Map as Map@@ -84,6 +87,7 @@ import Data.IORef import Data.List import qualified Data.List as List+import Data.Foldable (toList) import Data.Maybe import Data.Ord ( comparing ) import Data.Time@@ -130,10 +134,18 @@ text "Chasing modules from: ", hcat (punctuate comma (map pprTarget targets))]) - mod_graphE <- liftIO $ downsweep hsc_env old_graph+ -- Home package modules may have been moved or deleted, and new+ -- source files may have appeared in the home package that shadow+ -- external package modules, so we have to discard the existing+ -- cached finder data.+ liftIO $ flushFinderCaches hsc_env++ mod_summariesE <- liftIO $ downsweep hsc_env (mgModSummaries old_graph) excluded_mods allow_dup_roots- mod_graph <- reportImportErrors mod_graphE+ mod_summaries <- reportImportErrors mod_summariesE + let mod_graph = mkModuleGraph mod_summaries+ warnMissingHomeModules hsc_env mod_graph setSession hsc_env { hsc_mod_graph = mod_graph }@@ -185,7 +197,7 @@ is_my_target _ _ = False missing = map (moduleName . ms_mod) $- filter (not . is_known_module) mod_graph+ filter (not . is_known_module) (mgModSummaries mod_graph) msg | gopt Opt_BuildingCabalPackage dflags@@ -243,8 +255,9 @@ -- B.hs-boot in the module graph, but no B.hs -- The downsweep should have ensured this does not happen -- (see msDeps)- let all_home_mods = [ms_mod_name s- | s <- mod_graph, not (isBootSummary s)]+ let all_home_mods =+ mkUniqSet [ ms_mod_name s+ | s <- mgModSummaries mod_graph, not (isBootSummary s)] -- TODO: Figure out what the correct form of this assert is. It's violated -- when you have HsBootMerge nodes in the graph: then you'll have hs-boot -- files without corresponding hs files.@@ -259,7 +272,7 @@ checkHowMuch _ = id checkMod m and_then- | m `elem` all_home_mods = and_then+ | m `elementOfUniqSet` all_home_mods = and_then | otherwise = do liftIO $ errorMsg dflags (text "no such module:" <+> quotes (ppr m))@@ -302,7 +315,11 @@ -- Unload any modules which are going to be re-linked this time around. let stable_linkables = [ linkable- | m <- stable_obj++stable_bco,+ | m <- nonDetEltsUniqSet stable_obj +++ nonDetEltsUniqSet stable_bco,+ -- It's OK to use nonDetEltsUniqSet here+ -- because it only affects linking. Besides+ -- this list only serves as a poor man's set. Just hmi <- [lookupHpt pruned_hpt m], Just linkable <- [hm_linkable hmi] ] liftIO $ unload hsc_env stable_linkables@@ -348,24 +365,25 @@ stable_mg = [ AcyclicSCC ms | AcyclicSCC ms <- full_mg,- ms_mod_name ms `elem` stable_obj++stable_bco ]+ stable_mod_summary ms ] + stable_mod_summary ms =+ ms_mod_name ms `elementOfUniqSet` stable_obj ||+ ms_mod_name ms `elementOfUniqSet` stable_bco+ -- the modules from partial_mg that are not also stable -- NB. also keep cycles, we need to emit an error message later unstable_mg = filter not_stable partial_mg where not_stable (CyclicSCC _) = True not_stable (AcyclicSCC ms)- = ms_mod_name ms `notElem` stable_obj++stable_bco+ = not $ stable_mod_summary ms -- Load all the stable modules first, before attempting to load -- an unstable module (#7231). mg = stable_mg ++ unstable_mg -- clean up between compilations- let cleanup hsc_env = intermediateCleanTempFiles (hsc_dflags hsc_env)- (flattenSCCs mg2_with_srcimps)- hsc_env-+ let cleanup = cleanCurrentModuleTempFiles . hsc_dflags liftIO $ debugTraceMsg dflags 2 (hang (text "Ready for upsweep") 2 (ppr mg)) @@ -396,7 +414,7 @@ -- Clean up after ourselves hsc_env1 <- getSession- liftIO $ intermediateCleanTempFiles dflags modsDone hsc_env1+ liftIO $ cleanCurrentModuleTempFiles dflags -- Issue a warning for the confusing case where the user -- said '-o foo' but we're not going to do any linking.@@ -408,7 +426,7 @@ let no_hs_main = gopt Opt_NoHsMain dflags let main_mod = mainModIs dflags- a_root_is_Main = any ((==main_mod).ms_mod) mod_graph+ a_root_is_Main = mgElemModule mod_graph main_mod do_linking = a_root_is_Main || no_hs_main || ghcLink dflags == LinkDynLib || ghcLink dflags == LinkStaticLib -- link everything together@@ -437,29 +455,42 @@ let mods_to_zap_names = findPartiallyCompletedCycles modsDone_names mg2_with_srcimps- let mods_to_keep- = filter ((`Set.notMember` mods_to_zap_names).ms_mod)- modsDone-+ let (mods_to_clean, mods_to_keep) =+ partition ((`Set.member` mods_to_zap_names).ms_mod) modsDone hsc_env1 <- getSession- let hpt4 = retainInTopLevelEnvs (map ms_mod_name mods_to_keep)- (hsc_HPT hsc_env1)+ let hpt4 = hsc_HPT hsc_env1+ -- We must change the lifetime to TFL_CurrentModule for any temp+ -- file created for an element of mod_to_clean during the upsweep.+ -- These include preprocessed files and object files for loaded+ -- modules.+ unneeded_temps = concat+ [ms_hspp_file : object_files+ | ModSummary{ms_mod, ms_hspp_file} <- mods_to_clean+ , let object_files = maybe [] linkableObjs $+ lookupHpt hpt4 (moduleName ms_mod)+ >>= hm_linkable+ ]+ liftIO $+ changeTempFilesLifetime dflags TFL_CurrentModule unneeded_temps+ liftIO $ cleanCurrentModuleTempFiles dflags + let hpt5 = retainInTopLevelEnvs (map ms_mod_name mods_to_keep)+ hpt4+ -- Clean up after ourselves- liftIO $ intermediateCleanTempFiles dflags mods_to_keep hsc_env1 -- there should be no Nothings where linkables should be, now let just_linkables = isNoLink (ghcLink dflags) || allHpt (isJust.hm_linkable) (filterHpt ((== HsSrcFile).mi_hsc_src.hm_iface)- hpt4)+ hpt5) ASSERT( just_linkables ) do -- Link everything together- linkresult <- liftIO $ link (ghcLink dflags) dflags False hpt4+ linkresult <- liftIO $ link (ghcLink dflags) dflags False hpt5 - modifySession $ \hsc_env -> hsc_env{ hsc_HPT = hpt4 }+ modifySession $ \hsc_env -> hsc_env{ hsc_HPT = hpt5 } loadFinish Failed linkresult @@ -507,23 +538,6 @@ this_pkg = thisPackage dflags old_name = ic_name old_ic -intermediateCleanTempFiles :: DynFlags -> [ModSummary] -> HscEnv -> IO ()-intermediateCleanTempFiles dflags summaries hsc_env- = do notIntermediate <- readIORef (filesToNotIntermediateClean dflags)- cleanTempFilesExcept dflags (notIntermediate ++ except)- where- except =- -- Save preprocessed files. The preprocessed file *might* be- -- the same as the source file, but that doesn't do any- -- harm.- map ms_hspp_file summaries ++- -- Save object files for loaded modules. The point of this- -- is that we might have generated and compiled a stub C- -- file, and in the case of GHCi the object file will be a- -- temporary file which we must not remove because we need- -- to load/link it later.- hptObjs (hsc_HPT hsc_env)- -- | If there is no -o option, guess the name of target executable -- by using top-level source file name as a base. guessOutputFile :: GhcMonad m => m ()@@ -533,8 +547,7 @@ !mod_graph = hsc_mod_graph env mainModuleSrcPath :: Maybe String mainModuleSrcPath = do- let isMain = (== mainModIs dflags) . ms_mod- [ms] <- return (filter isMain mod_graph)+ ms <- mgLookupModule mod_graph (mainModIs dflags) ml_hs_file (ms_location ms) name = fmap dropExtension mainModuleSrcPath @@ -576,7 +589,7 @@ -- compilation. pruneHomePackageTable :: HomePackageTable -> [ModSummary]- -> ([ModuleName],[ModuleName])+ -> StableModules -> HomePackageTable pruneHomePackageTable hpt summ (stable_obj, stable_bco) = mapHpt prune hpt@@ -593,7 +606,9 @@ ms_map = listToUFM [(ms_mod_name ms, ms) | ms <- summ] - is_stable m = m `elem` stable_obj || m `elem` stable_bco+ is_stable m =+ m `elementOfUniqSet` stable_obj ||+ m `elementOfUniqSet` stable_bco -- ----------------------------------------------------------------------------- --@@ -676,29 +691,38 @@ has changed. The current code in GhcMake handles this case fairly poorly, so be careful. -}++type StableModules =+ ( UniqSet ModuleName -- stableObject+ , UniqSet ModuleName -- stableBCO+ )++ checkStability :: HomePackageTable -- HPT from last compilation -> [SCC ModSummary] -- current module graph (cyclic)- -> [ModuleName] -- all home modules- -> ([ModuleName], -- stableObject- [ModuleName]) -- stableBCO+ -> UniqSet ModuleName -- all home modules+ -> StableModules -checkStability hpt sccs all_home_mods = foldl checkSCC ([],[]) sccs+checkStability hpt sccs all_home_mods =+ foldl checkSCC (emptyUniqSet, emptyUniqSet) sccs where+ checkSCC :: StableModules -> SCC ModSummary -> StableModules checkSCC (stable_obj, stable_bco) scc0- | stableObjects = (scc_mods ++ stable_obj, stable_bco)- | stableBCOs = (stable_obj, scc_mods ++ stable_bco)+ | stableObjects = (addListToUniqSet stable_obj scc_mods, stable_bco)+ | stableBCOs = (stable_obj, addListToUniqSet stable_bco scc_mods) | otherwise = (stable_obj, stable_bco) where scc = flattenSCC scc0 scc_mods = map ms_mod_name scc- home_module m = m `elem` all_home_mods && m `notElem` scc_mods+ home_module m =+ m `elementOfUniqSet` all_home_mods && m `notElem` scc_mods scc_allimps = nub (filter home_module (concatMap ms_home_allimps scc)) -- all imports outside the current SCC, but in the home pkg - stable_obj_imps = map (`elem` stable_obj) scc_allimps- stable_bco_imps = map (`elem` stable_bco) scc_allimps+ stable_obj_imps = map (`elementOfUniqSet` stable_obj) scc_allimps+ stable_bco_imps = map (`elementOfUniqSet` stable_bco) scc_allimps stableObjects = and stable_obj_imps@@ -812,7 +836,7 @@ -- ^ The number of workers we wish to run in parallel -> Maybe Messager -> HomePackageTable- -> ([ModuleName],[ModuleName])+ -> StableModules -> (HscEnv -> IO ()) -> [SCC ModSummary] -> m (SuccessFlag,@@ -868,13 +892,19 @@ -- The list of all loops in the compilation graph. -- NB: For convenience, the last module of each loop (aka the module that -- finishes the loop) is prepended to the beginning of the loop.- let comp_graph_loops = go (map fstOf3 (reverse comp_graph))+ let graph = map fstOf3 (reverse comp_graph)+ boot_modules = mkModuleSet [ms_mod ms | ms <- graph, isBootSummary ms]+ comp_graph_loops = go graph boot_modules where- go [] = []- go (ms:mss) | Just loop <- getModLoop ms (ms:mss)- = map mkBuildModule (ms:loop) : go mss- | otherwise- = go mss+ remove ms bm+ | isBootSummary ms = delModuleSet bm (ms_mod ms)+ | otherwise = bm+ go [] _ = []+ go mg@(ms:mss) boot_modules+ | Just loop <- getModLoop ms mg (`elemModuleSet` boot_modules)+ = map mkBuildModule (ms:loop) : go mss (remove ms boot_modules)+ | otherwise+ = go mss (remove ms boot_modules) -- Build a Map out of the compilation graph with which we can efficiently -- look up the result MVar associated with a particular home module.@@ -905,7 +935,7 @@ -- compilation for that module is finished) without having to -- worry about accidentally deleting a simultaneous compile's -- important files.- lcl_files_to_clean <- newIORef []+ lcl_files_to_clean <- newIORef emptyFilesToClean let lcl_dflags = dflags { log_action = parLogAction log_queue , filesToClean = lcl_files_to_clean } @@ -938,9 +968,12 @@ -- Add the remaining files that weren't cleaned up to the -- global filesToClean ref, for cleanup later.- files_kept <- readIORef (filesToClean lcl_dflags)- addFilesToClean dflags files_kept-+ FilesToClean+ { ftcCurrentModule = cm_files+ , ftcGhcSession = gs_files+ } <- readIORef (filesToClean lcl_dflags)+ addFilesToClean dflags TFL_CurrentModule $ Set.toList cm_files+ addFilesToClean dflags TFL_GhcSession $ Set.toList gs_files -- Kill all the workers, masking interrupts (since killThread is -- interruptible). XXX: This is not ideal.@@ -1022,8 +1055,8 @@ -- ^ The MVar that synchronizes updates to the global HscEnv -> IORef HomePackageTable -- ^ The old HPT- -> ([ModuleName],[ModuleName])- -- ^ Lists of stable objects and BCOs+ -> StableModules+ -- ^ Sets of stable objects and BCOs -> Int -- ^ The index of this module -> Int@@ -1207,7 +1240,7 @@ :: GhcMonad m => Maybe Messager -> HomePackageTable -- ^ HPT from last time round (pruned)- -> ([ModuleName],[ModuleName]) -- ^ stable modules (see checkStability)+ -> StableModules -- ^ stable modules (see checkStability) -> (HscEnv -> IO ()) -- ^ How to clean up unwanted tmp files -> [SCC ModSummary] -- ^ Mods to do (the worklist) -> m (SuccessFlag,@@ -1220,12 +1253,22 @@ upsweep mHscMessage old_hpt stable_mods cleanup sccs = do dflags <- getSessionDynFlags- (res, done) <- upsweep' old_hpt [] sccs 1 (length sccs)+ (res, done) <- upsweep' old_hpt emptyMG sccs 1 (length sccs) (unitIdsToCheck dflags) done_holes- return (res, reverse done)+ return (res, reverse $ mgModSummaries done) where done_holes = emptyUniqSet + upsweep'+ :: GhcMonad m+ => HomePackageTable+ -> ModuleGraph+ -> [SCC ModSummary]+ -> Int+ -> Int+ -> [UnitId]+ -> UniqSet ModuleName+ -> m (SuccessFlag, ModuleGraph) upsweep' _old_hpt done [] _ _ uids_to_check _ = do hsc_env <- getSession@@ -1303,7 +1346,7 @@ old_hpt1 | isBootSummary mod = old_hpt | otherwise = delFromHpt old_hpt this_mod - done' = mod:done+ done' = extendMG done mod -- fixup our HomePackageTable after we've finished compiling -- a mutually-recursive loop. We have to do this again@@ -1352,7 +1395,7 @@ upsweep_mod :: HscEnv -> Maybe Messager -> HomePackageTable- -> ([ModuleName],[ModuleName])+ -> StableModules -> ModSummary -> Int -- index of module -> Int -- total number of modules@@ -1366,8 +1409,8 @@ obj_fn = ml_obj_file (ms_location summary) hs_date = ms_hs_date summary - is_stable_obj = this_mod_name `elem` stable_obj- is_stable_bco = this_mod_name `elem` stable_bco+ is_stable_obj = this_mod_name `elementOfUniqSet` stable_obj+ is_stable_bco = this_mod_name `elementOfUniqSet` stable_bco old_hmi = lookupHpt old_hpt this_mod_name @@ -1379,11 +1422,13 @@ -- If OPTIONS_GHC contains -fasm or -fllvm, be careful that -- we don't do anything dodgy: these should only work to change- -- from -fllvm to -fasm and vice-versa, otherwise we could- -- end up trying to link object code to byte code.+ -- from -fllvm to -fasm and vice-versa, or away from -fno-code,+ -- otherwise we could end up trying to link object code to byte+ -- code. target = if prevailing_target /= local_target && (not (isObjectTarget prevailing_target) || not (isObjectTarget local_target))+ && not (prevailing_target == HscNothing) then prevailing_target else local_target @@ -1500,7 +1545,7 @@ linkable <- liftIO $ findObjectLinkable this_mod obj_fn obj_date compile_it_discard_iface (Just linkable) SourceUnmodified - -- See Note [Recompilation checking when typechecking only]+ -- See Note [Recompilation checking in -fno-code mode] | writeInterfaceOnlyMode dflags, Just if_date <- mb_if_date, if_date >= hs_date -> do@@ -1513,7 +1558,71 @@ (text "compiling mod:" <+> ppr this_mod_name) compile_it Nothing SourceModified --- Note [Recompilation checking when typechecking only]++{- Note [-fno-code mode]+~~~~~~~~~~~~~~~~~~~~~~~~+GHC offers the flag -fno-code for the purpose of parsing and typechecking a+program without generating object files. This is intended to be used by tooling+and IDEs to provide quick feedback on any parser or type errors as cheaply as+possible.++When GHC is invoked with -fno-code no object files or linked output will be+generated. As many errors and warnings as possible will be generated, as if+-fno-code had not been passed. The session DynFlags will have+hscTarget == HscNothing.++-fwrite-interface+~~~~~~~~~~~~~~~~+Whether interface files are generated in -fno-code mode is controlled by the+-fwrite-interface flag. The -fwrite-interface flag is a no-op if -fno-code is+not also passed. Recompilation avoidance requires interface files, so passing+-fno-code without -fwrite-interface should be avoided. If -fno-code were+re-implemented today, -fwrite-interface would be discarded and it would be+considered always on; this behaviour is as it is for backwards compatibility.++================================================================+IN SUMMARY: ALWAYS PASS -fno-code AND -fwrite-interface TOGETHER+================================================================++Template Haskell+~~~~~~~~~~~~~~~~+A module using template haskell may invoke an imported function from inside a+splice. This will cause the type-checker to attempt to execute that code, which+would fail if no object files had been generated. See #8025. To rectify this,+during the downsweep we patch the DynFlags in the ModSummary of any home module+that is imported by a module that uses template haskell, to generate object+code.++The flavour of generated object code is chosen by defaultObjectTarget for the+target platform. It would likely be faster to generate bytecode, but this is not+supported on all platforms(?Please Confirm?), and does not support the entirety+of GHC haskell. See #1257.++The object files (and interface files if -fwrite-interface is disabled) produced+for template haskell are written to temporary files.++Note that since template haskell can run arbitrary IO actions, -fno-code mode+is no more secure than running without it.++Potential TODOS:+~~~~~+* Remove -fwrite-interface and have interface files always written in -fno-code+ mode+* Both .o and .dyn_o files are generated for template haskell, but we only need+ .dyn_o. Fix it.+* In make mode, a message like+ Compiling A (A.hs, /tmp/ghc_123.o)+ is shown if downsweep enabled object code generation for A. Perhaps we should+ show "nothing" or "temporary object file" instead. Note that one+ can currently use -keep-tmp-files and inspect the generated file with the+ current behaviour.+* Offer a -no-codedir command line option, and write what were temporary+ object files there. This would speed up recompilation.+* Use existing object files (if they are up to date) instead of always+ generating temporary ones.+-}++-- Note [Recompilation checking in -fno-code mode] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- If we are compiling with -fno-code -fwrite-interface, there won't -- be any object code that we can compare against, nor should there@@ -1521,7 +1630,6 @@ -- want to check if the interface file is new, in lieu of the object -- file. See also Trac #9243. - -- Filter modules in the HPT retainInTopLevelEnvs :: [ModuleName] -> HomePackageTable -> HomePackageTable retainInTopLevelEnvs keep_these hpt@@ -1562,7 +1670,7 @@ reTypecheckLoop :: HscEnv -> ModSummary -> ModuleGraph -> IO HscEnv reTypecheckLoop hsc_env ms graph- | Just loop <- getModLoop ms graph+ | Just loop <- getModLoop ms mss appearsAsBoot -- SOME hs-boot files should still -- get used, just not the loop-closer. , let non_boot = filter (\l -> not (isBootSummary l &&@@ -1570,6 +1678,9 @@ = typecheckLoop (hsc_dflags hsc_env) hsc_env (map ms_mod_name non_boot) | otherwise = return hsc_env+ where+ mss = mgModSummaries graph+ appearsAsBoot = (`elemModuleSet` mgBootModules graph) -- | Given a non-boot ModSummary @ms@ of a module, for which there exists a -- corresponding boot file in @graph@, return the set of modules which@@ -1607,10 +1718,14 @@ -- Arguably, D.hs should import A.hs, not A.hs-boot, but -- a dependency on the boot file is not illegal. ---getModLoop :: ModSummary -> ModuleGraph -> Maybe [ModSummary]-getModLoop ms graph+getModLoop+ :: ModSummary+ -> [ModSummary]+ -> (Module -> Bool) -- check if a module appears as a boot module in 'graph'+ -> Maybe [ModSummary]+getModLoop ms graph appearsAsBoot | not (isBootSummary ms)- , any (\m -> ms_mod m == this_mod && isBootSummary m) graph+ , appearsAsBoot this_mod , let mss = reachableBackwards (ms_mod_name ms) graph = Just mss | otherwise@@ -1640,7 +1755,7 @@ reachableBackwards :: ModuleName -> [ModSummary] -> [ModSummary] reachableBackwards mod summaries- = [ ms | (ms,_,_) <- reachableG (transposeG graph) root ]+ = [ node_payload node | node <- reachableG (transposeG graph) root ] where -- the rest just sets up the graph: (graph, lookup_node) = moduleGraphNodes False summaries root = expectJust "reachableBackwards" (lookup_node HsBootFile mod)@@ -1651,7 +1766,7 @@ topSortModuleGraph :: Bool -- ^ Drop hi-boot nodes? (see below)- -> [ModSummary]+ -> ModuleGraph -> Maybe ModuleName -- ^ Root module name. If @Nothing@, use the full graph. -> [SCC ModSummary]@@ -1670,12 +1785,14 @@ -- the a source-import of Foo is an import of Foo -- The resulting graph has no hi-boot nodes, but can be cyclic -topSortModuleGraph drop_hs_boot_nodes summaries mb_root_mod+topSortModuleGraph drop_hs_boot_nodes module_graph mb_root_mod = map (fmap summaryNodeSummary) $ stronglyConnCompG initial_graph where+ summaries = mgModSummaries module_graph -- stronglyConnCompG flips the original order, so if we reverse -- the summaries we get a stable topological sort.- (graph, lookup_node) = moduleGraphNodes drop_hs_boot_nodes (reverse summaries)+ (graph, lookup_node) =+ moduleGraphNodes drop_hs_boot_nodes (reverse summaries) initial_graph = case mb_root_mod of Nothing -> graph@@ -1684,17 +1801,20 @@ -- the specified module. We do this by building a graph with -- the full set of nodes, and determining the reachable set from -- the specified node.- let root | Just node <- lookup_node HsSrcFile root_mod, graph `hasVertexG` node = node- | otherwise = throwGhcException (ProgramError "module does not exist")+ let root | Just node <- lookup_node HsSrcFile root_mod+ , graph `hasVertexG` node+ = node+ | otherwise+ = throwGhcException (ProgramError "module does not exist") in graphFromEdgedVerticesUniq (seq root (reachableG graph root)) -type SummaryNode = (ModSummary, Int, [Int])+type SummaryNode = Node Int ModSummary summaryNodeKey :: SummaryNode -> Int-summaryNodeKey (_, k, _) = k+summaryNodeKey = node_key summaryNodeSummary :: SummaryNode -> ModSummary-summaryNodeSummary (s, _, _) = s+summaryNodeSummary = node_payload moduleGraphNodes :: Bool -> [ModSummary] -> (Graph SummaryNode, HscSource -> ModuleName -> Maybe SummaryNode)@@ -1712,11 +1832,12 @@ node_map :: NodeMap SummaryNode node_map = Map.fromList [ ((moduleName (ms_mod s), hscSourceToIsBoot (ms_hsc_src s)), node)- | node@(s, _, _) <- nodes ]+ | node <- nodes+ , let s = summaryNodeSummary node ] -- We use integers as the keys for the SCC algorithm nodes :: [SummaryNode]- nodes = [ (s, key, out_keys)+ nodes = [ DigraphNode s key out_keys | (s, key) <- numbered_summaries -- Drop the hi-boot ones if told to do so , not (isBootSummary s && drop_hs_boot_nodes)@@ -1824,8 +1945,17 @@ rootSummariesOk <- reportImportErrors rootSummaries let root_map = mkRootMap rootSummariesOk checkDuplicates root_map- summs <- loop (concatMap calcDeps rootSummariesOk) root_map- return summs+ map0 <- loop (concatMap calcDeps rootSummariesOk) root_map+ -- if we have been passed -fno-code, we enable code generation+ -- for dependencies of modules that have -XTemplateHaskell,+ -- otherwise those modules will fail to compile.+ -- See Note [-fno-code mode] #8025+ map1 <- if hscTarget dflags == HscNothing+ then enableCodeGenForTH+ (defaultObjectTarget (targetPlatform dflags))+ map0+ else return map0+ return $ concat $ nodeMapElts map1 where calcDeps = msDeps @@ -1872,16 +2002,15 @@ -- Visited set; the range is a list because -- the roots can have the same module names -- if allow_dup_roots is True- -> IO [Either ErrMsg ModSummary]- -- The result includes the worklist, except- -- for those mentioned in the visited set- loop [] done = return (concat (nodeMapElts done))+ -> IO (NodeMap [Either ErrMsg ModSummary])+ -- The result is the completed NodeMap+ loop [] done = return done loop ((wanted_mod, is_boot) : ss) done | Just summs <- Map.lookup key done = if isSingleton summs then loop ss done else- do { multiRootsErr dflags (rights summs); return [] }+ do { multiRootsErr dflags (rights summs); return Map.empty } | otherwise = do mb_s <- summariseModule hsc_env old_summary_map is_boot wanted_mod True@@ -1889,11 +2018,82 @@ case mb_s of Nothing -> loop ss done Just (Left e) -> loop ss (Map.insert key [Left e] done)- Just (Right s)-> loop (calcDeps s ++ ss)- (Map.insert key [Right s] done)+ Just (Right s)-> do+ new_map <-+ loop (calcDeps s) (Map.insert key [Right s] done)+ loop ss new_map where key = (unLoc wanted_mod, is_boot) +-- | Update the every ModSummary that is depended on+-- by a module that needs template haskell. We enable codegen to+-- the specified target, disable optimization and change the .hi+-- and .o file locations to be temporary files.+-- See Note [-fno-code mode]+enableCodeGenForTH :: HscTarget+ -> NodeMap [Either ErrMsg ModSummary]+ -> IO (NodeMap [Either ErrMsg ModSummary])+enableCodeGenForTH target nodemap =+ traverse (traverse (traverse enable_code_gen)) nodemap+ where+ enable_code_gen ms+ | ModSummary+ { ms_mod = ms_mod+ , ms_location = ms_location+ , ms_hsc_src = HsSrcFile+ , ms_hspp_opts = dflags@DynFlags+ {hscTarget = HscNothing}+ } <- ms+ , ms_mod `Set.member` needs_codegen_set+ = do+ let new_temp_file suf dynsuf = do+ tn <- newTempName dflags TFL_CurrentModule suf+ let dyn_tn = tn -<.> dynsuf+ addFilesToClean dflags TFL_GhcSession [dyn_tn]+ return tn+ -- We don't want to create .o or .hi files unless we have been asked+ -- to by the user. But we need them, so we patch their locations in+ -- the ModSummary with temporary files.+ --+ hi_file <-+ if gopt Opt_WriteInterface dflags+ then return $ ml_hi_file ms_location+ else new_temp_file (hiSuf dflags) (dynHiSuf dflags)+ o_temp_file <- new_temp_file (objectSuf dflags) (dynObjectSuf dflags)+ return $+ ms+ { ms_location =+ ms_location {ml_hi_file = hi_file, ml_obj_file = o_temp_file}+ , ms_hspp_opts = updOptLevel 0 $ dflags {hscTarget = target}+ }+ | otherwise = return ms++ needs_codegen_set = transitive_deps_set+ [ ms+ | mss <- Map.elems nodemap+ , Right ms <- mss+ , isTemplateHaskellOrQQNonBoot ms+ ]++ -- find the set of all transitive dependencies of a list of modules.+ transitive_deps_set modSums = foldl' go Set.empty modSums+ where+ go marked_mods ms@ModSummary{ms_mod}+ | ms_mod `Set.member` marked_mods = marked_mods+ | otherwise =+ let deps =+ [ dep_ms+ -- If a module imports a boot module, msDeps helpfully adds a+ -- dependency to that non-boot module in it's result. This+ -- means we don't have to think about boot modules here.+ | (L _ mn, NotBoot) <- msDeps ms+ , dep_ms <-+ toList (Map.lookup (mn, NotBoot) nodemap) >>= toList >>=+ toList+ ]+ new_marked_mods = Set.insert ms_mod marked_mods+ in foldl' go new_marked_mods deps+ mkRootMap :: [ModSummary] -> NodeMap [Either ErrMsg ModSummary] mkRootMap summaries = Map.insertListWith (flip (++)) [ (msKey s, [Right s]) | s <- summaries ]@@ -1981,6 +2181,12 @@ then liftIO $ getObjTimestamp location NotBoot else return Nothing hi_timestamp <- maybeGetIfaceDate dflags location++ -- We have to repopulate the Finder's cache because it+ -- was flushed before the downsweep.+ _ <- liftIO $ addHomeModuleToFinder hsc_env+ (moduleName (ms_mod old_summary)) (ms_location old_summary)+ return old_summary{ ms_obj_date = obj_timestamp , ms_iface_date = hi_timestamp } else@@ -2100,11 +2306,6 @@ new_summary location (ms_mod old_summary) src_fn src_timestamp find_it = do- -- Don't use the Finder's cache this time. If the module was- -- previously a package module, it may have now appeared on the- -- search path, so we want to consider it to be a home module. If- -- the module was previously a home module, it may have moved.- uncacheModule hsc_env wanted_mod found <- findImportedModule hsc_env wanted_mod Nothing case found of Found location mod@@ -2282,7 +2483,7 @@ , nest 2 (show_path path) ] where graph :: [Node NodeKey ModSummary]- graph = [(ms, msKey ms, get_deps ms) | ms <- mss]+ graph = [ DigraphNode ms (msKey ms) (get_deps ms) | ms <- mss] get_deps :: ModSummary -> [NodeKey] get_deps ms = ([ (unLoc m, IsBoot) | m <- ms_home_srcimps ms ] ++
main/GhcMonad.hs view
@@ -23,6 +23,8 @@ WarnErrLogger, defaultWarnErrLogger ) where +import GhcPrelude+ import MonadUtils import HscTypes import DynFlags
main/HeaderInfo.hs view
@@ -18,7 +18,8 @@ #include "HsVersions.h" -import RdrName+import GhcPrelude+ import HscTypes import Parser ( parseHeader ) import Lexer@@ -63,7 +64,9 @@ getImports dflags buf filename source_filename = do let loc = mkRealSrcLoc (mkFastString filename) 1 1 case unP parseHeader (mkPState dflags buf loc) of- PFailed span err -> parseError dflags span err+ PFailed _ span err -> do+ -- assuming we're not logging warnings here as per below+ parseError dflags span err POk pst rdr_module -> do let _ms@(_warns, errs) = getMessages pst dflags -- don't log warnings: they'll be reported when we parse the file@@ -97,8 +100,8 @@ mkPrelImports :: ModuleName -> SrcSpan -- Attribute the "import Prelude" to this location- -> Bool -> [LImportDecl RdrName]- -> [LImportDecl RdrName]+ -> Bool -> [LImportDecl GhcPs]+ -> [LImportDecl GhcPs] -- Construct the implicit declaration "import Prelude" (or not) -- -- NB: opt_NoImplicitPrelude is slightly different to import Prelude ();@@ -117,7 +120,7 @@ <- import_decls , unLoc mod == pRELUDE_NAME ] - preludeImportDecl :: LImportDecl RdrName+ preludeImportDecl :: LImportDecl GhcPs preludeImportDecl = L loc $ ImportDecl { ideclSourceSrc = NoSourceText, ideclName = L loc pRELUDE_NAME,
main/Hooks.hs view
@@ -2,8 +2,6 @@ -- NB: this module is SOURCE-imported by DynFlags, and should primarily -- refer to *types*, rather than *code*--- If you import too muchhere , then the revolting compiler_stage2_dll0_MODULES--- stuff in compiler/ghc.mk makes DynFlags link to too much stuff {-# LANGUAGE CPP #-} module Hooks ( Hooks@@ -25,24 +23,27 @@ , createIservProcessHook ) where +import GhcPrelude+ import DynFlags-import Name import PipelineMonad import HscTypes import HsDecls import HsBinds import HsExpr import OrdList-import Id import TcRnTypes import Bag import RdrName+import Name+import Id import CoreSyn import GHCi.RemoteTypes import SrcLoc import Type import System.Process import BasicTypes+import HsExtension import Data.Maybe @@ -75,17 +76,24 @@ } data Hooks = Hooks- { dsForeignsHook :: Maybe ([LForeignDecl Id] -> DsM (ForeignStubs, OrdList (Id, CoreExpr)))- , tcForeignImportsHook :: Maybe ([LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt))- , tcForeignExportsHook :: Maybe ([LForeignDecl Name] -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt))+ { dsForeignsHook :: Maybe ([LForeignDecl GhcTc]+ -> DsM (ForeignStubs, OrdList (Id, CoreExpr)))+ , tcForeignImportsHook :: Maybe ([LForeignDecl GhcRn]+ -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt))+ , tcForeignExportsHook :: Maybe ([LForeignDecl GhcRn]+ -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt)) , hscFrontendHook :: Maybe (ModSummary -> Hsc FrontendResult)- , hscCompileCoreExprHook :: Maybe (HscEnv -> SrcSpan -> CoreExpr -> IO ForeignHValue)+ , hscCompileCoreExprHook ::+ Maybe (HscEnv -> SrcSpan -> CoreExpr -> IO ForeignHValue) , ghcPrimIfaceHook :: Maybe ModIface- , runPhaseHook :: Maybe (PhasePlus -> FilePath -> DynFlags -> CompPipeline (PhasePlus, FilePath))+ , runPhaseHook :: Maybe (PhasePlus -> FilePath -> DynFlags+ -> CompPipeline (PhasePlus, FilePath)) , runMetaHook :: Maybe (MetaHook TcM)- , linkHook :: Maybe (GhcLink -> DynFlags -> Bool -> HomePackageTable -> IO SuccessFlag)- , runRnSpliceHook :: Maybe (HsSplice Name -> RnM (HsSplice Name))- , getValueSafelyHook :: Maybe (HscEnv -> Name -> Type -> IO (Maybe HValue))+ , linkHook :: Maybe (GhcLink -> DynFlags -> Bool+ -> HomePackageTable -> IO SuccessFlag)+ , runRnSpliceHook :: Maybe (HsSplice GhcRn -> RnM (HsSplice GhcRn))+ , getValueSafelyHook :: Maybe (HscEnv -> Name -> Type+ -> IO (Maybe HValue)) , createIservProcessHook :: Maybe (CreateProcess -> IO ProcessHandle) }
main/Hooks.hs-boot view
@@ -1,5 +1,7 @@ module Hooks where +import GhcPrelude ()+ data Hooks emptyHooks :: Hooks
main/HscMain.hs view
@@ -82,7 +82,10 @@ , hscAddSptEntries ) where +import GhcPrelude+ import Data.Data hiding (Fixity, TyCon)+import DynFlags (addPluginModuleName) import Id import GHCi ( addSptEntry ) import GHCi.RemoteTypes ( ForeignHValue )@@ -97,6 +100,7 @@ import ConLike import Control.Concurrent +import Avail ( Avails ) import Module import Packages import RdrName@@ -137,6 +141,7 @@ import Fingerprint ( Fingerprint ) import Hooks import TcEnv+import PrelNames import DynFlags import ErrUtils@@ -183,7 +188,7 @@ iserv_mvar <- newMVar Nothing return HscEnv { hsc_dflags = dflags , hsc_targets = []- , hsc_mod_graph = []+ , hsc_mod_graph = emptyMG , hsc_IC = emptyInteractiveContext dflags , hsc_HPT = emptyHomePackageTable , hsc_EPS = eps_var@@ -274,7 +279,8 @@ -- "name not found", and the Maybe in the return type -- is used to indicate that. -hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))+hscTcRnGetInfo :: HscEnv -> Name+ -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc)) hscTcRnGetInfo hsc_env0 name = runInteractiveHsc hsc_env0 $ do { hsc_env <- getHscEnv@@ -291,7 +297,7 @@ -- ----------------------------------------------------------------------------- -- | Rename some import declarations-hscRnImportDecls :: HscEnv -> [LImportDecl RdrName] -> IO GlobalRdrEnv+hscRnImportDecls :: HscEnv -> [LImportDecl GhcPs] -> IO GlobalRdrEnv hscRnImportDecls hsc_env0 import_decls = runInteractiveHsc hsc_env0 $ do hsc_env <- getHscEnv ioMsgMaybe $ tcRnImportDecls hsc_env import_decls@@ -328,7 +334,9 @@ | otherwise = parseModule case unP parseMod (mkPState dflags buf loc) of- PFailed span err ->+ PFailed warnFn span err -> do+ logWarningsReportErrors (warnFn dflags)+ handleWarnings liftIO $ throwOneError (mkPlainErrMsg dflags span err) POk pst rdr_module -> do@@ -336,7 +344,7 @@ liftIO $ dumpIfSet_dyn dflags Opt_D_dump_parsed "Parser" $ ppr rdr_module liftIO $ dumpIfSet_dyn dflags Opt_D_dump_parsed_ast "Parser AST" $- text (showAstData NoBlankSrcSpan rdr_module)+ showAstData NoBlankSrcSpan rdr_module liftIO $ dumpIfSet_dyn dflags Opt_D_source_stats "Source Statistics" $ ppSourceStats False rdr_module @@ -344,7 +352,7 @@ -- that the parser gave us, -- - eliminate files beginning with '<'. gcc likes to use -- pseudo-filenames like "<built-in>" and "<command-line>"- -- - normalise them (elimiante differences between ./f and f)+ -- - normalise them (eliminate differences between ./f and f) -- - filter out the preprocessed source file -- - filter out anything beginning with tmpdir -- - remove duplicates@@ -379,7 +387,7 @@ -- can become a Nothing and decide whether this should instead throw an -- exception/signal an error. type RenamedStuff =- (Maybe (HsGroup Name, [LImportDecl Name], Maybe [LIE Name],+ (Maybe (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe LHsDocString)) -- -----------------------------------------------------------------------------@@ -396,7 +404,7 @@ dflags <- getDynFlags liftIO $ dumpIfSet_dyn dflags Opt_D_dump_rn_ast "Renamer" $- text (showAstData NoBlankSrcSpan rn_info)+ showAstData NoBlankSrcSpan rn_info return (tc_result, rn_info) @@ -439,7 +447,7 @@ do hpm <- case mb_rdr_module of Just hpm -> return hpm Nothing -> hscParse' mod_summary- tc_result0 <- tcRnModule' hsc_env mod_summary keep_rn hpm+ tc_result0 <- tcRnModule' mod_summary keep_rn hpm if hsc_src == HsigFile then do (iface, _, _) <- liftIO $ hscSimpleIface hsc_env tc_result0 Nothing ioMsgMaybe $@@ -447,9 +455,10 @@ else return tc_result0 -- wrapper around tcRnModule to handle safe haskell extras-tcRnModule' :: HscEnv -> ModSummary -> Bool -> HsParsedModule+tcRnModule' :: ModSummary -> Bool -> HsParsedModule -> Hsc TcGblEnv-tcRnModule' hsc_env sum save_rn_syntax mod = do+tcRnModule' sum save_rn_syntax mod = do+ hsc_env <- getHscEnv tcg_res <- {-# SCC "Typecheck-Rename" #-} ioMsgMaybe $ tcRnModule hsc_env (ms_hsc_src sum) save_rn_syntax mod@@ -524,7 +533,7 @@ -------------------------------- It's the task of the compilation proper to compile Haskell, hs-boot and core-files to either byte-code, hard-code (C, asm, LLVM, ect) or to nothing at all+files to either byte-code, hard-code (C, asm, LLVM, etc.) or to nothing at all (the module is still parsed and type-checked. This feature is mostly used by IDE's and the likes). Compilation can happen in either 'one-shot', 'batch', 'nothing', or 'interactive' mode. 'One-shot' mode targets hard-code, 'batch'@@ -677,8 +686,6 @@ -- to get those warnings too. (But we'll always exit at that point -- because the desugarer runs ioMsgMaybe.) runHsc hsc_env $ do- let dflags = hsc_dflags hsc_env- e <- hscIncrementalFrontend always_do_basic_recompilation_check m_tc_result mHscMessage mod_summary source_modified mb_old_iface mod_index case e of@@ -706,61 +713,59 @@ -- the interface that existed on disk; it's possible we had -- to retypecheck but the resulting interface is exactly -- the same.)- Right (FrontendTypecheck tc_result, mb_old_hash) -> do- (status, hmi, no_change)- <- case ms_hsc_src mod_summary of- HsSrcFile | hscTarget dflags /= HscNothing ->- finish hsc_env mod_summary tc_result mb_old_hash- _ ->- finishTypecheckOnly hsc_env mod_summary tc_result mb_old_hash- liftIO $ hscMaybeWriteIface dflags (hm_iface hmi) no_change mod_summary- return (status, hmi)---- Generates and writes out the final interface for a typecheck.-finishTypecheckOnly :: HscEnv- -> ModSummary- -> TcGblEnv- -> Maybe Fingerprint- -> Hsc (HscStatus, HomeModInfo, Bool)-finishTypecheckOnly hsc_env summary tc_result mb_old_hash = do- let dflags = hsc_dflags hsc_env- (iface, changed, details) <- liftIO $ hscSimpleIface hsc_env tc_result mb_old_hash- let hsc_status =- case (hscTarget dflags, ms_hsc_src summary) of- (HscNothing, _) -> HscNotGeneratingCode- (_, HsBootFile) -> HscUpdateBoot- (_, HsigFile) -> HscUpdateSig- _ -> panic "finishTypecheckOnly"- return (hsc_status,- HomeModInfo{ hm_details = details,- hm_iface = iface,- hm_linkable = Nothing },- changed)+ Right (FrontendTypecheck tc_result, mb_old_hash) ->+ finish mod_summary tc_result mb_old_hash -- Runs the post-typechecking frontend (desugar and simplify), -- and then generates and writes out the final interface. We want -- to write the interface AFTER simplification so we can get -- as up-to-date and good unfoldings and other info as possible--- in the interface file. This is only ever run for HsSrcFile,--- and NOT for HscNothing.-finish :: HscEnv- -> ModSummary+-- in the interface file.+finish :: ModSummary -> TcGblEnv -> Maybe Fingerprint- -> Hsc (HscStatus, HomeModInfo, Bool)-finish hsc_env summary tc_result mb_old_hash = do- let dflags = hsc_dflags hsc_env- MASSERT( ms_hsc_src summary == HsSrcFile )- MASSERT( hscTarget dflags /= HscNothing )- guts0 <- hscDesugar' (ms_location summary) tc_result- guts <- hscSimplify' guts0- (iface, changed, details, cgguts) <- liftIO $ hscNormalIface hsc_env guts mb_old_hash-- return (HscRecomp cgguts summary,- HomeModInfo{ hm_details = details,- hm_iface = iface,- hm_linkable = Nothing },- changed)+ -> Hsc (HscStatus, HomeModInfo)+finish summary tc_result mb_old_hash = do+ hsc_env <- getHscEnv+ let dflags = hsc_dflags hsc_env+ target = hscTarget dflags+ hsc_src = ms_hsc_src summary+ should_desugar =+ ms_mod summary /= gHC_PRIM && hsc_src == HsSrcFile+ mk_simple_iface = do+ let hsc_status =+ case (target, hsc_src) of+ (HscNothing, _) -> HscNotGeneratingCode+ (_, HsBootFile) -> HscUpdateBoot+ (_, HsigFile) -> HscUpdateSig+ _ -> panic "finish"+ (iface, changed, details) <- liftIO $+ hscSimpleIface hsc_env tc_result mb_old_hash+ return (iface, changed, details, hsc_status)+ (iface, changed, details, hsc_status) <-+ -- we usually desugar even when we are not generating code, otherwise+ -- we would miss errors thrown by the desugaring (see #10600). The only+ -- exceptions are when the Module is Ghc.Prim or when+ -- it is not a HsSrcFile Module.+ if should_desugar+ then do+ desugared_guts0 <- hscDesugar' (ms_location summary) tc_result+ if target == HscNothing+ -- We are not generating code, so we can skip simplification+ -- and generate a simple interface.+ then mk_simple_iface+ else do+ plugins <- liftIO $ readIORef (tcg_th_coreplugins tc_result)+ desugared_guts <- hscSimplify' plugins desugared_guts0+ (iface, changed, details, cgguts) <-+ liftIO $ hscNormalIface hsc_env desugared_guts mb_old_hash+ return (iface, changed, details, HscRecomp cgguts summary)+ else mk_simple_iface+ liftIO $ hscMaybeWriteIface dflags iface changed summary+ return+ ( hsc_status+ , HomeModInfo+ {hm_details = details, hm_iface = iface, hm_linkable = Nothing}) hscMaybeWriteIface :: DynFlags -> ModIface -> Bool -> ModSummary -> IO () hscMaybeWriteIface dflags iface changed summary =@@ -880,7 +885,7 @@ hscCheckSafeImports :: TcGblEnv -> Hsc TcGblEnv hscCheckSafeImports tcg_env = do dflags <- getDynFlags- tcg_env' <- checkSafeImports dflags tcg_env+ tcg_env' <- checkSafeImports tcg_env checkRULES dflags tcg_env' where@@ -917,9 +922,10 @@ -- RnNames.rnImportDecl for where package trust dependencies for a module are -- collected and unioned. Specifically see the Note [RnNames . Tracking Trust -- Transitively] and the Note [RnNames . Trust Own Package].-checkSafeImports :: DynFlags -> TcGblEnv -> Hsc TcGblEnv-checkSafeImports dflags tcg_env+checkSafeImports :: TcGblEnv -> Hsc TcGblEnv+checkSafeImports tcg_env = do+ dflags <- getDynFlags imps <- mapM condense imports' let (safeImps, regImps) = partition (\(_,_,s) -> s) imps @@ -955,8 +961,8 @@ tcg_env' <- case (not infPassed) of True -> markUnsafeInfer tcg_env infErrs False -> return tcg_env- when (packageTrustOn dflags) $ checkPkgTrust dflags pkgReqs- let newTrust = pkgTrustReqs safePkgs infPkgs infPassed+ when (packageTrustOn dflags) $ checkPkgTrust pkgReqs+ let newTrust = pkgTrustReqs dflags safePkgs infPkgs infPassed return tcg_env' { tcg_imports = impInfo `plusImportAvails` newTrust } where@@ -975,7 +981,9 @@ cond' :: ImportedModsVal -> ImportedModsVal -> Hsc ImportedModsVal cond' v1 v2 | imv_is_safe v1 /= imv_is_safe v2- = throwErrors $ unitBag $ mkPlainErrMsg dflags (imv_span v1)+ = do+ dflags <- getDynFlags+ throwErrors $ unitBag $ mkPlainErrMsg dflags (imv_span v1) (text "Module" <+> ppr (imv_name v1) <+> (text $ "is imported both as a safe and unsafe import!")) | otherwise@@ -983,18 +991,19 @@ -- easier interface to work with checkSafe :: (Module, SrcSpan, a) -> Hsc (Maybe InstalledUnitId)- checkSafe (m, l, _) = fst `fmap` hscCheckSafe' dflags m l+ checkSafe (m, l, _) = fst `fmap` hscCheckSafe' m l -- what pkg's to add to our trust requirements- pkgTrustReqs :: Set InstalledUnitId -> Set InstalledUnitId -> Bool -> ImportAvails- pkgTrustReqs req inf infPassed | safeInferOn dflags+ pkgTrustReqs :: DynFlags -> Set InstalledUnitId -> Set InstalledUnitId ->+ Bool -> ImportAvails+ pkgTrustReqs dflags req inf infPassed | safeInferOn dflags && safeHaskell dflags == Sf_None && infPassed = emptyImportAvails { imp_trust_pkgs = req `S.union` inf }- pkgTrustReqs _ _ _ | safeHaskell dflags == Sf_Unsafe+ pkgTrustReqs dflags _ _ _ | safeHaskell dflags == Sf_Unsafe = emptyImportAvails- pkgTrustReqs req _ _ = emptyImportAvails { imp_trust_pkgs = req }+ pkgTrustReqs _ req _ _ = emptyImportAvails { imp_trust_pkgs = req } -- | Check that a module is safe to import. --@@ -1003,16 +1012,15 @@ hscCheckSafe :: HscEnv -> Module -> SrcSpan -> IO Bool hscCheckSafe hsc_env m l = runHsc hsc_env $ do dflags <- getDynFlags- pkgs <- snd `fmap` hscCheckSafe' dflags m l- when (packageTrustOn dflags) $ checkPkgTrust dflags pkgs+ pkgs <- snd `fmap` hscCheckSafe' m l+ when (packageTrustOn dflags) $ checkPkgTrust pkgs errs <- getWarnings return $ isEmptyBag errs -- | Return if a module is trusted and the pkgs it depends on to be trusted. hscGetSafe :: HscEnv -> Module -> SrcSpan -> IO (Bool, Set InstalledUnitId) hscGetSafe hsc_env m l = runHsc hsc_env $ do- dflags <- getDynFlags- (self, pkgs) <- hscCheckSafe' dflags m l+ (self, pkgs) <- hscCheckSafe' m l good <- isEmptyBag `fmap` getWarnings clearWarnings -- don't want them printed... let pkgs' | Just p <- self = S.insert p pkgs@@ -1023,18 +1031,21 @@ -- Return (regardless of trusted or not) if the trust type requires the modules -- own package be trusted and a list of other packages required to be trusted -- (these later ones haven't been checked) but the own package trust has been.-hscCheckSafe' :: DynFlags -> Module -> SrcSpan -> Hsc (Maybe InstalledUnitId, Set InstalledUnitId)-hscCheckSafe' dflags m l = do+hscCheckSafe' :: Module -> SrcSpan+ -> Hsc (Maybe InstalledUnitId, Set InstalledUnitId)+hscCheckSafe' m l = do+ dflags <- getDynFlags (tw, pkgs) <- isModSafe m l case tw of- False -> return (Nothing, pkgs)- True | isHomePkg m -> return (Nothing, pkgs)+ False -> return (Nothing, pkgs)+ True | isHomePkg dflags m -> return (Nothing, pkgs) -- TODO: do we also have to check the trust of the instantiation? -- Not necessary if that is reflected in dependencies | otherwise -> return (Just $ toInstalledUnitId (moduleUnitId m), pkgs) where isModSafe :: Module -> SrcSpan -> Hsc (Bool, Set InstalledUnitId) isModSafe m l = do+ dflags <- getDynFlags iface <- lookup' m case iface of -- can't load iface to check trust!@@ -1049,7 +1060,7 @@ -- check module is trusted safeM = trust `elem` [Sf_Safe, Sf_Trustworthy] -- check package is trusted- safeP = packageTrusted trust trust_own_pkg m+ safeP = packageTrusted dflags trust trust_own_pkg m -- pkg trust reqs pkgRs = S.fromList . map fst $ filter snd $ dep_pkgs $ mi_deps iface' -- General errors we throw but Safe errors we log@@ -1077,18 +1088,19 @@ -- modules are trusted without requiring that their package is trusted. For -- trustworthy modules, modules in the home package are trusted but -- otherwise we check the package trust flag.- packageTrusted :: SafeHaskellMode -> Bool -> Module -> Bool- packageTrusted Sf_None _ _ = False -- shouldn't hit these cases- packageTrusted Sf_Unsafe _ _ = False -- prefer for completeness.- packageTrusted _ _ _- | not (packageTrustOn dflags) = True- packageTrusted Sf_Safe False _ = True- packageTrusted _ _ m- | isHomePkg m = True- | otherwise = trusted $ getPackageDetails dflags (moduleUnitId m)+ packageTrusted :: DynFlags -> SafeHaskellMode -> Bool -> Module -> Bool+ packageTrusted _ Sf_None _ _ = False -- shouldn't hit these cases+ packageTrusted _ Sf_Unsafe _ _ = False -- prefer for completeness.+ packageTrusted dflags _ _ _+ | not (packageTrustOn dflags) = True+ packageTrusted _ Sf_Safe False _ = True+ packageTrusted dflags _ _ m+ | isHomePkg dflags m = True+ | otherwise = trusted $ getPackageDetails dflags (moduleUnitId m) lookup' :: Module -> Hsc (Maybe ModIface) lookup' m = do+ dflags <- getDynFlags hsc_env <- getHscEnv hsc_eps <- liftIO $ hscEPS hsc_env let pkgIfaceT = eps_PIT hsc_eps@@ -1103,19 +1115,16 @@ return iface' - isHomePkg :: Module -> Bool- isHomePkg m+ isHomePkg :: DynFlags -> Module -> Bool+ isHomePkg dflags m | thisPackage dflags == moduleUnitId m = True | otherwise = False -- | Check the list of packages are trusted.-checkPkgTrust :: DynFlags -> Set InstalledUnitId -> Hsc ()-checkPkgTrust dflags pkgs =- case errors of- [] -> return ()- _ -> (liftIO . throwIO . mkSrcErr . listToBag) errors- where- errors = S.foldr go [] pkgs+checkPkgTrust :: Set InstalledUnitId -> Hsc ()+checkPkgTrust pkgs = do+ dflags <- getDynFlags+ let errors = S.foldr go [] pkgs go pkg acc | trusted $ getInstalledPackageDetails dflags pkg = acc@@ -1123,6 +1132,9 @@ = (:acc) $ mkErrMsg dflags noSrcSpan (pkgQual dflags) $ text "The package (" <> ppr pkg <> text ") is required" <> text " to be trusted but it isn't!"+ case errors of+ [] -> return ()+ _ -> (liftIO . throwIO . mkSrcErr . listToBag) errors -- | Set module to unsafe and (potentially) wipe trust information. --@@ -1143,7 +1155,7 @@ mkPlainWarnMsg dflags (warnUnsafeOnLoc dflags) (whyUnsafe' dflags)) liftIO $ writeIORef (tcg_safeInfer tcg_env) (False, whyUnsafe)- -- NOTE: Only wipe trust when not in an explicity safe haskell mode. Other+ -- NOTE: Only wipe trust when not in an explicitly safe haskell mode. Other -- times inference may be on but we are in Trustworthy mode -- so we want -- to record safe-inference failed but not wipe the trust dependencies. case safeHaskell dflags == Sf_None of@@ -1186,14 +1198,18 @@ -- Simplifiers -------------------------------------------------------------- -hscSimplify :: HscEnv -> ModGuts -> IO ModGuts-hscSimplify hsc_env modguts = runHsc hsc_env $ hscSimplify' modguts+hscSimplify :: HscEnv -> [String] -> ModGuts -> IO ModGuts+hscSimplify hsc_env plugins modguts =+ runHsc hsc_env $ hscSimplify' plugins modguts -hscSimplify' :: ModGuts -> Hsc ModGuts-hscSimplify' ds_result = do+hscSimplify' :: [String] -> ModGuts -> Hsc ModGuts+hscSimplify' plugins ds_result = do hsc_env <- getHscEnv+ let hsc_env_with_plugins = hsc_env+ { hsc_dflags = foldr addPluginModuleName (hsc_dflags hsc_env) plugins+ } {-# SCC "Core2Core" #-}- liftIO $ core2core hsc_env ds_result+ liftIO $ core2core hsc_env_with_plugins ds_result -------------------------------------------------------------- -- Interface generators@@ -1293,15 +1309,17 @@ ------------------- -- PREPARE FOR CODE GENERATION -- Do saturation and convert to A-normal form- prepd_binds <- {-# SCC "CorePrep" #-}+ (prepd_binds, local_ccs) <- {-# SCC "CorePrep" #-} corePrepPgm hsc_env this_mod location core_binds data_tycons ----------------- Convert to STG ------------------- (stg_binds, cost_centre_info)+ (stg_binds, (caf_ccs, caf_cc_stacks)) <- {-# SCC "CoreToStg" #-} myCoreToStg dflags this_mod prepd_binds - let prof_init = profilingInitCode this_mod cost_centre_info+ let cost_centre_info =+ (S.toList local_ccs ++ caf_ccs, caf_cc_stacks)+ prof_init = profilingInitCode this_mod cost_centre_info foreign_stubs = foreign_stubs0 `appendStubC` prof_init ------------------ Code generation ------------------@@ -1358,7 +1376,7 @@ ------------------- -- PREPARE FOR CODE GENERATION -- Do saturation and convert to A-normal form- prepd_binds <- {-# SCC "CorePrep" #-}+ (prepd_binds, _) <- {-# SCC "CorePrep" #-} corePrepPgm hsc_env this_mod location core_binds data_tycons ----------------- Generate byte code ------------------ comp_bc <- byteCodeGen hsc_env this_mod prepd_binds data_tycons mod_breaks@@ -1462,15 +1480,15 @@ myCoreToStg :: DynFlags -> Module -> CoreProgram -> IO ( [StgTopBinding] -- output program- , CollectedCCs) -- cost centre info (declared and used)+ , CollectedCCs ) -- CAF cost centre info (declared and used) myCoreToStg dflags this_mod prepd_binds = do- let stg_binds+ let (stg_binds, cost_centre_info) = {-# SCC "Core2Stg" #-} coreToStg dflags this_mod prepd_binds - (stg_binds2, cost_centre_info)+ stg_binds2 <- {-# SCC "Stg2Stg" #-}- stg2stg dflags this_mod stg_binds+ stg2stg dflags stg_binds return (stg_binds2, cost_centre_info) @@ -1519,7 +1537,7 @@ liftIO $ hscParsedStmt hsc_env parsed_stmt hscParsedStmt :: HscEnv- -> GhciLStmt RdrName -- ^ The parsed statement+ -> GhciLStmt GhcPs -- ^ The parsed statement -> IO ( Maybe ([Id] , ForeignHValue {- IO [HValue] -} , FixityEnv))@@ -1576,7 +1594,9 @@ ds_result <- hscDesugar' iNTERACTIVELoc tc_gblenv {- Simplify -}- simpl_mg <- liftIO $ hscSimplify hsc_env ds_result+ simpl_mg <- liftIO $ do+ plugins <- readIORef (tcg_th_coreplugins tc_gblenv)+ hscSimplify hsc_env plugins ds_result {- Tidy -} (tidy_cg, mod_details) <- liftIO $ tidyProgram hsc_env simpl_mg@@ -1594,7 +1614,7 @@ {- Prepare For Code Generation -} -- Do saturation and convert to A-normal form- prepd_binds <- {-# SCC "CorePrep" #-}+ (prepd_binds, _) <- {-# SCC "CorePrep" #-} liftIO $ corePrepPgm hsc_env this_mod iNTERACTIVELoc core_binds data_tycons {- Generate byte code -}@@ -1654,7 +1674,7 @@ -} -hscImport :: HscEnv -> String -> IO (ImportDecl RdrName)+hscImport :: HscEnv -> String -> IO (ImportDecl GhcPs) hscImport hsc_env str = runInteractiveHsc hsc_env $ do (L _ (HsModule{hsmodImports=is})) <- hscParseThing parseModule str@@ -1686,7 +1706,7 @@ ty <- hscParseType str ioMsgMaybe $ tcRnType hsc_env normalise ty -hscParseExpr :: String -> Hsc (LHsExpr RdrName)+hscParseExpr :: String -> Hsc (LHsExpr GhcPs) hscParseExpr expr = do hsc_env <- getHscEnv maybe_stmt <- hscParseStmt expr@@ -1695,15 +1715,15 @@ _ -> throwErrors $ unitBag $ mkPlainErrMsg (hsc_dflags hsc_env) noSrcSpan (text "not an expression:" <+> quotes (text expr)) -hscParseStmt :: String -> Hsc (Maybe (GhciLStmt RdrName))+hscParseStmt :: String -> Hsc (Maybe (GhciLStmt GhcPs)) hscParseStmt = hscParseThing parseStmt hscParseStmtWithLocation :: String -> Int -> String- -> Hsc (Maybe (GhciLStmt RdrName))+ -> Hsc (Maybe (GhciLStmt GhcPs)) hscParseStmtWithLocation source linenumber stmt = hscParseThingWithLocation source linenumber parseStmt stmt -hscParseType :: String -> Hsc (LHsType RdrName)+hscParseType :: String -> Hsc (LHsType GhcPs) hscParseType = hscParseThing parseType hscParseIdentifier :: HscEnv -> String -> IO (Located RdrName)@@ -1726,7 +1746,9 @@ loc = mkRealSrcLoc (fsLit source) linenumber 1 case unP parser (mkPState dflags buf loc) of- PFailed span err -> do+ PFailed warnFn span err -> do+ logWarningsReportErrors (warnFn dflags)+ handleWarnings let msg = mkPlainErrMsg dflags span err throwErrors $ unitBag msg @@ -1734,7 +1756,7 @@ logWarningsReportErrors (getMessages pst dflags) liftIO $ dumpIfSet_dyn dflags Opt_D_dump_parsed "Parser" (ppr thing) liftIO $ dumpIfSet_dyn dflags Opt_D_dump_parsed_ast "Parser AST" $- text $ showAstData NoBlankSrcSpan thing+ showAstData NoBlankSrcSpan thing return thing
main/HscStats.hs view
@@ -8,10 +8,11 @@ module HscStats ( ppSourceStats ) where +import GhcPrelude+ import Bag import HsSyn import Outputable-import RdrName import SrcLoc import Util @@ -19,7 +20,7 @@ import Data.Foldable (foldl') -- | Source Statistics-ppSourceStats :: Bool -> Located (HsModule RdrName) -> SDoc+ppSourceStats :: Bool -> Located (HsModule GhcPs) -> SDoc ppSourceStats short (L _ (HsModule _ exports imports ldecls _ _)) = (if short then hcat else vcat) (map pp_val
main/HscTypes.hs view
@@ -5,6 +5,7 @@ -} {-# LANGUAGE CPP, ScopedTypeVariables #-}+{-# LANGUAGE RecordWildCards #-} -- | Types for the per-module compiler module HscTypes (@@ -12,10 +13,14 @@ HscEnv(..), hscEPS, FinderCache, FindResult(..), InstalledFindResult(..), Target(..), TargetId(..), pprTarget, pprTargetId,- ModuleGraph, emptyMG, HscStatus(..), IServ(..), + -- * ModuleGraph+ ModuleGraph, emptyMG, mkModuleGraph, extendMG, mapMG,+ mgModSummaries, mgElemModule, mgLookupModule,+ needsTemplateHaskellOrQQ, mgBootModules,+ -- * Hsc monad Hsc(..), runHsc, runInteractiveHsc, @@ -27,7 +32,7 @@ ModSummary(..), ms_imps, ms_installed_mod, ms_mod_name, showModMsg, isBootSummary, msHsFilePath, msHiFilePath, msObjFilePath,- SourceModified(..),+ SourceModified(..), isTemplateHaskellOrQQNonBoot, -- * Information about the module being compiled -- (re-exported from DriverPhases)@@ -40,7 +45,6 @@ addToHpt, addListToHpt, lookupHptDirectly, listToHpt, hptCompleteSigs, hptInstances, hptRules, hptVectInfo, pprHPT,- hptObjs, -- * State relating to known packages ExternalPackageState(..), EpsStats(..), addEpsInStats,@@ -142,6 +146,8 @@ #include "HsVersions.h" +import GhcPrelude+ import ByteCodeTypes import InteractiveEvalTypes ( Resume ) import GHCi.Message ( Pipe )@@ -178,6 +184,7 @@ , eqTyConName ) import TysWiredIn import Packages hiding ( Version(..) )+import CmdLineParser import DynFlags import DriverPhases ( Phase, HscSource(..), isHsBootOrSig, hscSourceString ) import BasicTypes@@ -199,9 +206,10 @@ import Util import UniqDSet import GHC.Serialized ( Serialized )+import qualified GHC.LanguageExtensions as LangExt import Foreign-import Control.Monad ( guard, liftM, when, ap )+import Control.Monad ( guard, liftM, ap ) import Data.Foldable ( foldl' ) import Data.IORef import Data.Time@@ -320,22 +328,42 @@ -- | Given a bag of warnings, turn them into an exception if -- -Werror is enabled, or print them out otherwise. printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO ()-printOrThrowWarnings dflags warns- | anyBag (isWarnMsgFatal dflags) warns- = throwIO $ mkSrcErr $ warns `snocBag` warnIsErrorMsg dflags- | otherwise- = printBagOfErrors dflags warns+printOrThrowWarnings dflags warns = do+ let (make_error, warns') =+ mapAccumBagL+ (\make_err warn ->+ case isWarnMsgFatal dflags warn of+ Nothing ->+ (make_err, warn)+ Just err_reason ->+ (True, warn{ errMsgSeverity = SevError+ , errMsgReason = ErrReason err_reason+ }))+ False warns+ if make_error+ then throwIO (mkSrcErr warns')+ else printBagOfErrors dflags warns -handleFlagWarnings :: DynFlags -> [Located String] -> IO ()-handleFlagWarnings dflags warns- = when (wopt Opt_WarnDeprecatedFlags dflags) $ do- -- It would be nicer if warns :: [Located MsgDoc], but that- -- has circular import problems.- let bag = listToBag [ mkPlainWarnMsg dflags loc (text warn)- | L loc warn <- warns ]+handleFlagWarnings :: DynFlags -> [Warn] -> IO ()+handleFlagWarnings dflags warns = do+ let warns' = filter (shouldPrintWarning dflags . warnReason) warns - printOrThrowWarnings dflags bag+ -- It would be nicer if warns :: [Located MsgDoc], but that+ -- has circular import problems.+ bag = listToBag [ mkPlainWarnMsg dflags loc (text warn)+ | Warn _ (L loc warn) <- warns' ] + printOrThrowWarnings dflags bag++-- Given a warn reason, check to see if it's associated -W opt is enabled+shouldPrintWarning :: DynFlags -> CmdLineParser.WarnReason -> Bool+shouldPrintWarning dflags ReasonDeprecatedFlag+ = wopt Opt_WarnDeprecatedFlags dflags+shouldPrintWarning dflags ReasonUnrecognisedFlag+ = wopt Opt_WarnUnrecognisedWarningFlags dflags+shouldPrintWarning _ _+ = True+ {- ************************************************************************ * *@@ -688,8 +716,6 @@ -- And get its dfuns , thing <- things ] -hptObjs :: HomePackageTable -> [FilePath]-hptObjs hpt = concat (map (maybe [] linkableObjs . hm_linkable) (eltsHpt hpt)) {- ************************************************************************@@ -701,35 +727,35 @@ -- | The supported metaprogramming result types data MetaRequest- = MetaE (LHsExpr RdrName -> MetaResult)- | MetaP (LPat RdrName -> MetaResult)- | MetaT (LHsType RdrName -> MetaResult)- | MetaD ([LHsDecl RdrName] -> MetaResult)- | MetaAW (Serialized -> MetaResult)+ = MetaE (LHsExpr GhcPs -> MetaResult)+ | MetaP (LPat GhcPs -> MetaResult)+ | MetaT (LHsType GhcPs -> MetaResult)+ | MetaD ([LHsDecl GhcPs] -> MetaResult)+ | MetaAW (Serialized -> MetaResult) -- | data constructors not exported to ensure correct result type data MetaResult- = MetaResE { unMetaResE :: LHsExpr RdrName }- | MetaResP { unMetaResP :: LPat RdrName }- | MetaResT { unMetaResT :: LHsType RdrName }- | MetaResD { unMetaResD :: [LHsDecl RdrName] }+ = MetaResE { unMetaResE :: LHsExpr GhcPs }+ | MetaResP { unMetaResP :: LPat GhcPs }+ | MetaResT { unMetaResT :: LHsType GhcPs }+ | MetaResD { unMetaResD :: [LHsDecl GhcPs] } | MetaResAW { unMetaResAW :: Serialized } -type MetaHook f = MetaRequest -> LHsExpr Id -> f MetaResult+type MetaHook f = MetaRequest -> LHsExpr GhcTc -> f MetaResult -metaRequestE :: Functor f => MetaHook f -> LHsExpr Id -> f (LHsExpr RdrName)+metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs) metaRequestE h = fmap unMetaResE . h (MetaE MetaResE) -metaRequestP :: Functor f => MetaHook f -> LHsExpr Id -> f (LPat RdrName)+metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs) metaRequestP h = fmap unMetaResP . h (MetaP MetaResP) -metaRequestT :: Functor f => MetaHook f -> LHsExpr Id -> f (LHsType RdrName)+metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs) metaRequestT h = fmap unMetaResT . h (MetaT MetaResT) -metaRequestD :: Functor f => MetaHook f -> LHsExpr Id -> f [LHsDecl RdrName]+metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs] metaRequestD h = fmap unMetaResD . h (MetaD MetaResD) -metaRequestAW :: Functor f => MetaHook f -> LHsExpr Id -> f Serialized+metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized metaRequestAW h = fmap unMetaResAW . h (MetaAW MetaResAW) {-@@ -831,7 +857,10 @@ mi_iface_hash :: !Fingerprint, -- ^ Hash of the whole interface mi_mod_hash :: !Fingerprint, -- ^ Hash of the ABI only mi_flag_hash :: !Fingerprint, -- ^ Hash of the important flags- -- used when compiling this module+ -- used when compiling the module,+ -- excluding optimisation flags+ mi_opt_hash :: !Fingerprint, -- ^ Hash of optimisation flags+ mi_hpc_hash :: !Fingerprint, -- ^ Hash of hpc flags mi_orphan :: !WhetherHasOrphans, -- ^ Whether this module has orphans mi_finsts :: !WhetherHasFamInst,@@ -992,6 +1021,8 @@ mi_iface_hash= iface_hash, mi_mod_hash = mod_hash, mi_flag_hash = flag_hash,+ mi_opt_hash = opt_hash,+ mi_hpc_hash = hpc_hash, mi_orphan = orphan, mi_finsts = hasFamInsts, mi_deps = deps,@@ -1018,6 +1049,8 @@ put_ bh iface_hash put_ bh mod_hash put_ bh flag_hash+ put_ bh opt_hash+ put_ bh hpc_hash put_ bh orphan put_ bh hasFamInsts lazyPut bh deps@@ -1046,6 +1079,8 @@ iface_hash <- get bh mod_hash <- get bh flag_hash <- get bh+ opt_hash <- get bh+ hpc_hash <- get bh orphan <- get bh hasFamInsts <- get bh deps <- lazyGet bh@@ -1073,6 +1108,8 @@ mi_iface_hash = iface_hash, mi_mod_hash = mod_hash, mi_flag_hash = flag_hash,+ mi_opt_hash = opt_hash,+ mi_hpc_hash = hpc_hash, mi_orphan = orphan, mi_finsts = hasFamInsts, mi_deps = deps,@@ -1110,6 +1147,8 @@ mi_iface_hash = fingerprint0, mi_mod_hash = fingerprint0, mi_flag_hash = fingerprint0,+ mi_opt_hash = fingerprint0,+ mi_hpc_hash = fingerprint0, mi_orphan = False, mi_finsts = False, mi_hsc_src = HsSrcFile,@@ -1545,7 +1584,7 @@ } data InteractiveImport- = IIDecl (ImportDecl RdrName)+ = IIDecl (ImportDecl GhcPs) -- ^ Bring the exports of a particular module -- (filtered by an import decl) into scope @@ -2578,7 +2617,6 @@ soExt platform = case platformOS platform of OSDarwin -> "dylib"- OSiOS -> "dylib" OSMinGW32 -> "dll" _ -> "so" @@ -2598,11 +2636,73 @@ -- -- The graph is not necessarily stored in topologically-sorted order. Use -- 'GHC.topSortModuleGraph' and 'Digraph.flattenSCC' to achieve this.-type ModuleGraph = [ModSummary]+data ModuleGraph = ModuleGraph+ { mg_mss :: [ModSummary]+ , mg_non_boot :: ModuleEnv ModSummary+ -- a map of all non-boot ModSummaries keyed by Modules+ , mg_boot :: ModuleSet+ -- a set of boot Modules+ , mg_needs_th_or_qq :: !Bool+ -- does any of the modules in mg_mss require TemplateHaskell or+ -- QuasiQuotes?+ } +-- | Determines whether a set of modules requires Template Haskell or+-- Quasi Quotes+--+-- Note that if the session's 'DynFlags' enabled Template Haskell when+-- 'depanal' was called, then each module in the returned module graph will+-- have Template Haskell enabled whether it is actually needed or not.+needsTemplateHaskellOrQQ :: ModuleGraph -> Bool+needsTemplateHaskellOrQQ mg = mg_needs_th_or_qq mg++-- | Map a function 'f' over all the 'ModSummaries'.+-- To preserve invariants 'f' can't change the isBoot status.+mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph+mapMG f mg@ModuleGraph{..} = mg+ { mg_mss = map f mg_mss+ , mg_non_boot = mapModuleEnv f mg_non_boot+ }++mgBootModules :: ModuleGraph -> ModuleSet+mgBootModules ModuleGraph{..} = mg_boot++mgModSummaries :: ModuleGraph -> [ModSummary]+mgModSummaries = mg_mss++mgElemModule :: ModuleGraph -> Module -> Bool+mgElemModule ModuleGraph{..} m = elemModuleEnv m mg_non_boot++-- | Look up a ModSummary in the ModuleGraph+mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary+mgLookupModule ModuleGraph{..} m = lookupModuleEnv mg_non_boot m+ emptyMG :: ModuleGraph-emptyMG = []+emptyMG = ModuleGraph [] emptyModuleEnv emptyModuleSet False +isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool+isTemplateHaskellOrQQNonBoot ms =+ (xopt LangExt.TemplateHaskell (ms_hspp_opts ms)+ || xopt LangExt.QuasiQuotes (ms_hspp_opts ms)) &&+ not (isBootSummary ms)++-- | Add a ModSummary to ModuleGraph. Assumes that the new ModSummary is+-- not an element of the ModuleGraph.+extendMG :: ModuleGraph -> ModSummary -> ModuleGraph+extendMG ModuleGraph{..} ms = ModuleGraph+ { mg_mss = ms:mg_mss+ , mg_non_boot = if isBootSummary ms+ then mg_non_boot+ else extendModuleEnv mg_non_boot (ms_mod ms) ms+ , mg_boot = if isBootSummary ms+ then extendModuleSet mg_boot (ms_mod ms)+ else mg_boot+ , mg_needs_th_or_qq = mg_needs_th_or_qq || isTemplateHaskellOrQQNonBoot ms+ }++mkModuleGraph :: [ModSummary] -> ModuleGraph+mkModuleGraph = foldr (flip extendMG) emptyMG+ -- | A single node in a 'ModuleGraph'. The nodes of the module graph -- are one of: --@@ -2624,7 +2724,7 @@ ms_iface_date :: Maybe UTCTime, -- ^ Timestamp of hi file, if we *only* are typechecking (it is -- 'Nothing' otherwise.- -- See Note [Recompilation checking when typechecking only] and #9243+ -- See Note [Recompilation checking in -fno-code mode] and #9243 ms_srcimps :: [(Maybe FastString, Located ModuleName)], -- ^ Source imports of the module ms_textual_imps :: [(Maybe FastString, Located ModuleName)],@@ -2936,7 +3036,7 @@ -} data HsParsedModule = HsParsedModule {- hpm_module :: Located (HsModule RdrName),+ hpm_module :: Located (HsModule GhcPs), hpm_src_files :: [FilePath], -- ^ extra source files (e.g. from #includes). The lexer collects -- these from '# <file> <line>' pragmas, which the C preprocessor
main/InteractiveEval.hs view
@@ -40,6 +40,8 @@ #include "HsVersions.h" +import GhcPrelude+ import InteractiveEvalTypes import GHCi@@ -80,6 +82,7 @@ import Outputable import FastString import Bag+import Util import qualified Lexer (P (..), ParseResult(..), unP, mkPState) import qualified Parser (parseStmt, parseModule, parseDeclaration, parseImport) @@ -245,7 +248,7 @@ gbracket set_cwd reset_cwd $ \_ -> m -parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)+parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs) parseImportDecl expr = withSession $ \hsc_env -> liftIO $ hscImport hsc_env expr emptyHistory :: Int -> BoundedList History@@ -400,7 +403,7 @@ history = resumeHistory r new_ix = fn ix --- when (new_ix > length history) $ liftIO $+ when (history `lengthLessThan` new_ix) $ liftIO $ throwGhcExceptionIO (ProgramError "no more logged breakpoints") when (new_ix < 0) $ liftIO $ throwGhcExceptionIO (ProgramError "already at the beginning of the history")@@ -673,7 +676,7 @@ ([], imods_env) -> Right (foldr plusGlobalRdrEnv idecls_env imods_env) (err : _, _) -> Left err } where- idecls :: [LImportDecl RdrName]+ idecls :: [LImportDecl GhcPs] idecls = [noLoc d | IIDecl d <- imports] imods :: [ModuleName]@@ -725,20 +728,21 @@ -- are in scope (qualified or otherwise). Otherwise we list a whole lot too many! -- The exact choice of which ones to show, and which to hide, is a judgement call. -- (see Trac #1581)-getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing,Fixity,[ClsInst],[FamInst]))+getInfo :: GhcMonad m => Bool -> Name+ -> m (Maybe (TyThing,Fixity,[ClsInst],[FamInst], SDoc)) getInfo allInfo name = withSession $ \hsc_env -> do mb_stuff <- liftIO $ hscTcRnGetInfo hsc_env name case mb_stuff of Nothing -> return Nothing- Just (thing, fixity, cls_insts, fam_insts) -> do+ Just (thing, fixity, cls_insts, fam_insts, docs) -> do let rdr_env = ic_rn_gbl_env (hsc_IC hsc_env) -- Filter the instances based on whether the constituent names of their -- instance heads are all in scope. let cls_insts' = filter (plausible rdr_env . orphNamesOfClsInst) cls_insts fam_insts' = filter (plausible rdr_env . orphNamesOfFamInst) fam_insts- return (Just (thing, fixity, cls_insts', fam_insts'))+ return (Just (thing, fixity, cls_insts', fam_insts', docs)) where plausible rdr_env names -- Dfun involving only names that are in ic_rn_glb_env@@ -782,14 +786,14 @@ isStmt dflags stmt = case parseThing Parser.parseStmt dflags stmt of Lexer.POk _ _ -> True- Lexer.PFailed _ _ -> False+ Lexer.PFailed _ _ _ -> False -- | Returns @True@ if passed string has an import declaration. hasImport :: DynFlags -> String -> Bool hasImport dflags stmt = case parseThing Parser.parseModule dflags stmt of Lexer.POk _ thing -> hasImports thing- Lexer.PFailed _ _ -> False+ Lexer.PFailed _ _ _ -> False where hasImports = not . null . hsmodImports . unLoc @@ -798,7 +802,7 @@ isImport dflags stmt = case parseThing Parser.parseImport dflags stmt of Lexer.POk _ _ -> True- Lexer.PFailed _ _ -> False+ Lexer.PFailed _ _ _ -> False -- | Returns @True@ if passed string is a declaration but __/not a splice/__. isDecl :: DynFlags -> String -> Bool@@ -808,7 +812,7 @@ case unLoc thing of SpliceD _ -> False _ -> True- Lexer.PFailed _ _ -> False+ Lexer.PFailed _ _ _ -> False parseThing :: Lexer.P thing -> DynFlags -> String -> Lexer.ParseResult thing parseThing parser dflags stmt = do@@ -836,29 +840,29 @@ liftIO $ hscKcType hsc_env normalise str -------------------------------------------------------------------------------- Compile an expression, run it and deliver the result+-- Compile an expression, run it, and deliver the result -- | Parse an expression, the parsed expression can be further processed and -- passed to compileParsedExpr.-parseExpr :: GhcMonad m => String -> m (LHsExpr RdrName)+parseExpr :: GhcMonad m => String -> m (LHsExpr GhcPs) parseExpr expr = withSession $ \hsc_env -> do liftIO $ runInteractiveHsc hsc_env $ hscParseExpr expr --- | Compile an expression, run it and deliver the resulting HValue.+-- | Compile an expression, run it, and deliver the resulting HValue. compileExpr :: GhcMonad m => String -> m HValue compileExpr expr = do parsed_expr <- parseExpr expr compileParsedExpr parsed_expr --- | Compile an expression, run it and deliver the resulting HValue.+-- | Compile an expression, run it, and deliver the resulting HValue. compileExprRemote :: GhcMonad m => String -> m ForeignHValue compileExprRemote expr = do parsed_expr <- parseExpr expr compileParsedExprRemote parsed_expr --- | Compile an parsed expression (before renaming), run it and deliver+-- | Compile a parsed expression (before renaming), run it, and deliver -- the resulting HValue.-compileParsedExprRemote :: GhcMonad m => LHsExpr RdrName -> m ForeignHValue+compileParsedExprRemote :: GhcMonad m => LHsExpr GhcPs -> m ForeignHValue compileParsedExprRemote expr@(L loc _) = withSession $ \hsc_env -> do -- > let _compileParsedExpr = expr -- Create let stmt from expr to make hscParsedStmt happy.@@ -878,7 +882,7 @@ liftIO $ throwIO (fromSerializableException e) _ -> panic "compileParsedExpr" -compileParsedExpr :: GhcMonad m => LHsExpr RdrName -> m HValue+compileParsedExpr :: GhcMonad m => LHsExpr GhcPs -> m HValue compileParsedExpr expr = do fhv <- compileParsedExprRemote expr dflags <- getDynFlags
main/InteractiveEvalTypes.hs view
@@ -1,5 +1,3 @@-{-# LANGUAGE CPP #-}- -- ----------------------------------------------------------------------------- -- -- (c) The University of Glasgow, 2005-2007@@ -14,6 +12,8 @@ BreakInfo(..) ) where +import GhcPrelude+ import GHCi.RemoteTypes import GHCi.Message (EvalExpr, ResumeContext) import Id@@ -25,11 +25,7 @@ import Exception import Data.Word-#if MIN_VERSION_base(4,9,0) import GHC.Stack.CCS-#else-import GHC.Stack as GHC.Stack.CCS-#endif data ExecOptions = ExecOptions
main/PackageConfig.hs view
@@ -30,6 +30,8 @@ #include "HsVersions.h" +import GhcPrelude+ import GHC.PackageDb import Data.Version
main/Packages.hs view
@@ -46,6 +46,7 @@ getPackageConfigMap, getPreloadPackagesAnd, + collectArchives, collectIncludeDirs, collectLibraryPaths, collectLinkOpts, packageHsLibs, @@ -61,6 +62,8 @@ #include "HsVersions.h" +import GhcPrelude+ import GHC.PackageDb import PackageConfig import DynFlags@@ -71,6 +74,7 @@ import Module import Util import Panic+import Platform import Outputable import Maybes @@ -88,12 +92,9 @@ import Data.List as List import Data.Map (Map) import Data.Set (Set)-import Data.Maybe (mapMaybe) import Data.Monoid (First(..))-#if __GLASGOW_HASKELL__ > 710 import Data.Semigroup ( Semigroup ) import qualified Data.Semigroup as Semigroup-#endif import qualified Data.Map as Map import qualified Data.Map.Strict as MapStrict import qualified Data.Set as Set@@ -123,7 +124,7 @@ -- Let @depExposedPackages@ be the transitive closure from @exposedPackages@ of -- their dependencies. ----- * When searching for a module from an preload import declaration,+-- * When searching for a module from a preload import declaration, -- only the exposed modules in @exposedPackages@ are valid. -- -- * When searching for a module from an implicit import, all modules@@ -207,7 +208,6 @@ fromFlag :: ModuleOrigin fromFlag = ModOrigin Nothing [] [] True -#if __GLASGOW_HASKELL__ > 710 instance Semigroup ModuleOrigin where ModOrigin e res rhs f <> ModOrigin e' res' rhs' f' = ModOrigin (g e e') (res ++ res') (rhs ++ rhs') (f || f')@@ -217,18 +217,10 @@ g Nothing x = x g x Nothing = x _x <> _y = panic "ModOrigin: hidden module redefined"-#endif instance Monoid ModuleOrigin where mempty = ModOrigin Nothing [] [] False- mappend (ModOrigin e res rhs f) (ModOrigin e' res' rhs' f') =- ModOrigin (g e e') (res ++ res') (rhs ++ rhs') (f || f')- where g (Just b) (Just b')- | b == b' = Just b- | otherwise = panic "ModOrigin: package both exposed/hidden"- g Nothing x = x- g x Nothing = x- mappend _ _ = panic "ModOrigin: hidden module redefined"+ mappend = (Semigroup.<>) -- | Is the name from the import actually visible? (i.e. does it cause -- ambiguity, or is it only relevant when we're making suggestions?)@@ -287,6 +279,17 @@ uv_requirements = reqs, uv_explicit = explicit }) = ppr (b, rns, mb_pn, reqs, explicit)++instance Semigroup UnitVisibility where+ uv1 <> uv2+ = UnitVisibility+ { uv_expose_all = uv_expose_all uv1 || uv_expose_all uv2+ , uv_renamings = uv_renamings uv1 ++ uv_renamings uv2+ , uv_package_name = mappend (uv_package_name uv1) (uv_package_name uv2)+ , uv_requirements = Map.unionWith Set.union (uv_requirements uv1) (uv_requirements uv2)+ , uv_explicit = uv_explicit uv1 || uv_explicit uv2+ }+ instance Monoid UnitVisibility where mempty = UnitVisibility { uv_expose_all = False@@ -295,14 +298,7 @@ , uv_requirements = Map.empty , uv_explicit = False }- mappend uv1 uv2- = UnitVisibility- { uv_expose_all = uv_expose_all uv1 || uv_expose_all uv2- , uv_renamings = uv_renamings uv1 ++ uv_renamings uv2- , uv_package_name = mappend (uv_package_name uv1) (uv_package_name uv2)- , uv_requirements = Map.unionWith Set.union (uv_requirements uv1) (uv_requirements uv2)- , uv_explicit = uv_explicit uv1 || uv_explicit uv2- }+ mappend = (Semigroup.<>) type WiredUnitId = DefUnitId type PreloadUnitId = InstalledUnitId@@ -1695,6 +1691,13 @@ concatMap (map ("-l" ++) . extraLibraries) ps, concatMap ldOptions ps )+collectArchives :: DynFlags -> PackageConfig -> IO [FilePath]+collectArchives dflags pc =+ filterM doesFileExist [ searchPath </> ("lib" ++ lib ++ ".a")+ | searchPath <- searchPaths+ , lib <- libs ]+ where searchPaths = nub . filter notNull . libraryDirsForWay dflags $ pc+ libs = packageHsLibs dflags pc ++ extraLibraries pc packageHsLibs :: DynFlags -> PackageConfig -> [String] packageHsLibs dflags p = map (mkDynName . addSuffix) (hsLibraries p)@@ -1726,7 +1729,19 @@ | otherwise = panic ("Don't understand library name " ++ x) + -- Add _thr and other rts suffixes to packages named+ -- `rts` or `rts-1.0`. Why both? Traditionally the rts+ -- package is called `rts` only. However the tooling+ -- usually expects a package name to have a version.+ -- As such we will gradually move towards the `rts-1.0`+ -- package name, at which point the `rts` package name+ -- will eventually be unused.+ --+ -- This change elevates the need to add custom hooks+ -- and handling specifically for the `rts` package for+ -- example in ghc-cabal. addSuffix rts@"HSrts" = rts ++ (expandTag rts_tag)+ addSuffix rts@"HSrts-1.0"= rts ++ (expandTag rts_tag) addSuffix other_lib = other_lib ++ (expandTag tag) expandTag t | null t = ""@@ -1877,8 +1892,14 @@ getPreloadPackagesAnd :: DynFlags -> [PreloadUnitId] -> IO [PackageConfig] getPreloadPackagesAnd dflags pkgids0 = let- pkgids = pkgids0 ++ map (toInstalledUnitId . moduleUnitId . snd)- (thisUnitIdInsts dflags)+ pkgids = pkgids0 +++ -- An indefinite package will have insts to HOLE,+ -- which is not a real package. Don't look it up.+ -- Fixes #14525+ if isIndefinite dflags+ then []+ else map (toInstalledUnitId . moduleUnitId . snd)+ (thisUnitIdInsts dflags) state = pkgState dflags pkg_map = pkgIdMap state preload = preloadPackages state@@ -1973,16 +1994,19 @@ -- In the mean time, always force dynamic indirections to be -- generated: when the module name isn't the module being -- compiled, references are dynamic.- = if mod /= this_mod- then True- else case dllSplit dflags of- Nothing -> False- Just ss ->- let findMod m = let modStr = moduleNameString (moduleName m)- in case find (modStr `Set.member`) ss of- Just i -> i- Nothing -> panic ("Can't find " ++ modStr ++ "in DLL split")- in findMod mod /= findMod this_mod+ = case platformOS $ targetPlatform dflags of+ -- On Windows the hack for #8696 makes it unlinkable.+ -- As the entire setup of the code from Cmm down to the RTS expects+ -- the use of trampolines for the imported functions only when+ -- doing intra-package linking, e.g. refering to a symbol defined in the same+ -- package should not use a trampoline.+ -- I much rather have dynamic TH not supported than the entire Dynamic linking+ -- not due to a hack.+ -- Also not sure this would break on Windows anyway.+ OSMinGW32 -> moduleUnitId mod /= moduleUnitId this_mod++ -- For the other platforms, still perform the hack+ _ -> mod /= this_mod | otherwise = False -- no, it is not even an external name
main/Packages.hs-boot view
@@ -1,4 +1,5 @@ module Packages where+import GhcPrelude import {-# SOURCE #-} DynFlags(DynFlags) import {-# SOURCE #-} Module(ComponentId, UnitId, InstalledUnitId) data PackageState
main/PipelineMonad.hs view
@@ -9,12 +9,15 @@ , getPipeEnv, getPipeState, setDynFlags, setModLocation, setForeignOs ) where +import GhcPrelude+ import MonadUtils import Outputable import DynFlags import DriverPhases import HscTypes import Module+import FileCleanup (TempFileLifetime) import Control.Monad @@ -72,7 +75,7 @@ } data PipelineOutput- = Temporary+ = Temporary TempFileLifetime -- ^ Output should be to a temporary file: we're going to -- run more compilation steps on this output later. | Persistent
main/PlatformConstants.hs view
@@ -10,6 +10,8 @@ module PlatformConstants (PlatformConstants(..)) where +import GhcPrelude+ -- Produced by deriveConstants #include "GHCConstantsHaskellType.hs"
main/Plugins.hs view
@@ -1,8 +1,10 @@ module Plugins (- FrontendPlugin(..), defaultFrontendPlugin,+ FrontendPlugin(..), defaultFrontendPlugin, FrontendPluginAction, Plugin(..), CommandLineOption, defaultPlugin ) where++import GhcPrelude import CoreMonad ( CoreToDo, CoreM ) import TcRnTypes ( TcPlugin )
main/PprTyThing.hs view
@@ -19,6 +19,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Type ( TyThing(..) ) import IfaceSyn ( ShowSub(..), ShowHowMuch(..), AltPpr(..) , showToHeader, pprIfaceDecl )
main/StaticPtrTable.hs view
@@ -60,13 +60,13 @@ in ...(static k)... * The renamer looks for out-of-scope names in the body of the static- form, as always If all names are in scope, the free variables of the+ form, as always. If all names are in scope, the free variables of the body are stored in AST at the location of the static form. * The typechecker verifies that all free variables occurring in the static form are floatable to top level (see Note [Meaning of- IdBindingInfo] in TcRnTypes). In our example, 'k' is floatable, even- though it is bound in a nested let, we are fine.+ IdBindingInfo] in TcRnTypes). In our example, 'k' is floatable.+ Even though it is bound in a nested let, we are fine. * The desugarer replaces the static form with an application of the function 'makeStatic' (defined in module GHC.StaticPtr.Internal of@@ -121,6 +121,8 @@ process' SPT table using the addSptEntry interpreter message. This happens in upsweep after we have compiled the module (see GhcMake.upsweep'). -}++import GhcPrelude import CLabel import CoreSyn
main/SysTools.hs view
@@ -11,1722 +11,523 @@ {-# LANGUAGE CPP, MultiWayIf, ScopedTypeVariables #-} module SysTools (- -- Initialisation- initSysTools,-- -- Interface to system tools- runUnlit, runCpp, runCc, -- [Option] -> IO ()- runPp, -- [Option] -> IO ()- runSplit, -- [Option] -> IO ()- runAs, runLink, runLibtool, -- [Option] -> IO ()- runMkDLL,- runWindres,- runLlvmOpt,- runLlvmLlc,- runClang,- figureLlvmVersion,-- getLinkerInfo,- getCompilerInfo,-- linkDynLib,-- askLd,-- touch, -- String -> String -> IO ()- copy,- copyWithHeader,-- -- Temporary-file management- setTmpDir,- newTempName, newTempLibName,- cleanTempDirs, cleanTempFiles, cleanTempFilesExcept,- addFilesToClean,-- Option(..),-- -- platform-specifics- libmLinkOpts,-- -- frameworks- getPkgFrameworkOpts,- getFrameworkOpts--- ) where--#include "HsVersions.h"--import DriverPhases-import Module-import Packages-import Config-import Outputable-import ErrUtils-import Panic-import Platform-import Util-import DynFlags-import Exception--import LlvmCodeGen.Base (llvmVersionStr, supportedLlvmVersion)--import Data.IORef-import Control.Monad-import System.Exit-import System.Environment-import System.FilePath-import System.IO-import System.IO.Error as IO-import System.Directory-import Data.Char-import Data.List-import qualified Data.Map as Map-import qualified Data.Set as Set--#ifndef mingw32_HOST_OS-import qualified System.Posix.Internals-#else /* Must be Win32 */-import Foreign-import Foreign.C.String-#if MIN_VERSION_Win32(2,5,0)-import qualified System.Win32.Types as Win32-#else-import qualified System.Win32.Info as Win32-#endif-import System.Win32.Types (DWORD, LPTSTR, HANDLE)-import System.Win32.Types (failIfNull, failIf, iNVALID_HANDLE_VALUE)-import System.Win32.File (createFile,closeHandle, gENERIC_READ, fILE_SHARE_READ, oPEN_EXISTING, fILE_ATTRIBUTE_NORMAL, fILE_FLAG_BACKUP_SEMANTICS )-import System.Win32.DLL (loadLibrary, getProcAddress)-#endif--import System.Process-import Control.Concurrent-import FastString-import SrcLoc ( SrcLoc, mkSrcLoc, noSrcSpan, mkSrcSpan )--#ifdef mingw32_HOST_OS-# if defined(i386_HOST_ARCH)-# define WINDOWS_CCONV stdcall-# elif defined(x86_64_HOST_ARCH)-# define WINDOWS_CCONV ccall-# else-# error Unknown mingw32 arch-# endif-#endif--{--How GHC finds its files-~~~~~~~~~~~~~~~~~~~~~~~--[Note topdir]--GHC needs various support files (library packages, RTS etc), plus-various auxiliary programs (cp, gcc, etc). It starts by finding topdir,-the root of GHC's support files--On Unix:- - ghc always has a shell wrapper that passes a -B<dir> option--On Windows:- - ghc never has a shell wrapper.- - we can find the location of the ghc binary, which is- $topdir/<foo>/<something>.exe- where <something> may be "ghc", "ghc-stage2", or similar- - we strip off the "<foo>/<something>.exe" to leave $topdir.--from topdir we can find package.conf, ghc-asm, etc.---SysTools.initSysProgs figures out exactly where all the auxiliary programs-are, and initialises mutable variables to make it easy to call them.-To to this, it makes use of definitions in Config.hs, which is a Haskell-file containing variables whose value is figured out by the build system.--Config.hs contains two sorts of things-- cGCC, The *names* of the programs- cCPP e.g. cGCC = gcc- cUNLIT cCPP = gcc -E- etc They do *not* include paths--- cUNLIT_DIR The *path* to the directory containing unlit, split etc- cSPLIT_DIR *relative* to the root of the build tree,- for use when running *in-place* in a build tree (only)--------------------------------------------------NOTES for an ALTERNATIVE scheme (i.e *not* what is currently implemented):--Another hair-brained scheme for simplifying the current tool location-nightmare in GHC: Simon originally suggested using another-configuration file along the lines of GCC's specs file - which is fine-except that it means adding code to read yet another configuration-file. What I didn't notice is that the current package.conf is-general enough to do this:--Package- {name = "tools", import_dirs = [], source_dirs = [],- library_dirs = [], hs_libraries = [], extra_libraries = [],- include_dirs = [], c_includes = [], package_deps = [],- extra_ghc_opts = ["-pgmc/usr/bin/gcc","-pgml${topdir}/bin/unlit", ... etc.],- extra_cc_opts = [], extra_ld_opts = []}--Which would have the advantage that we get to collect together in one-place the path-specific package stuff with the path-specific tool-stuff.- End of NOTES------------------------------------------------************************************************************************-* *-\subsection{Initialisation}-* *-************************************************************************--}--initSysTools :: Maybe String -- Maybe TopDir path (without the '-B' prefix)- -> IO Settings -- Set all the mutable variables above, holding- -- (a) the system programs- -- (b) the package-config file- -- (c) the GHC usage message-initSysTools mbMinusB- = do top_dir <- findTopDir mbMinusB- -- see [Note topdir]- -- NB: top_dir is assumed to be in standard Unix- -- format, '/' separated-- let settingsFile = top_dir </> "settings"- platformConstantsFile = top_dir </> "platformConstants"- installed :: FilePath -> FilePath- installed file = top_dir </> file- libexec :: FilePath -> FilePath- libexec file = top_dir </> "bin" </> file-- settingsStr <- readFile settingsFile- platformConstantsStr <- readFile platformConstantsFile- mySettings <- case maybeReadFuzzy settingsStr of- Just s ->- return s- Nothing ->- pgmError ("Can't parse " ++ show settingsFile)- platformConstants <- case maybeReadFuzzy platformConstantsStr of- Just s ->- return s- Nothing ->- pgmError ("Can't parse " ++- show platformConstantsFile)- let getSetting key = case lookup key mySettings of- Just xs ->- return $ case stripPrefix "$topdir" xs of- Just [] ->- top_dir- Just xs'@(c:_)- | isPathSeparator c ->- top_dir ++ xs'- _ ->- xs- Nothing -> pgmError ("No entry for " ++ show key ++ " in " ++ show settingsFile)- getBooleanSetting key = case lookup key mySettings of- Just "YES" -> return True- Just "NO" -> return False- Just xs -> pgmError ("Bad value for " ++ show key ++ ": " ++ show xs)- Nothing -> pgmError ("No entry for " ++ show key ++ " in " ++ show settingsFile)- readSetting key = case lookup key mySettings of- Just xs ->- case maybeRead xs of- Just v -> return v- Nothing -> pgmError ("Failed to read " ++ show key ++ " value " ++ show xs)- Nothing -> pgmError ("No entry for " ++ show key ++ " in " ++ show settingsFile)- crossCompiling <- getBooleanSetting "cross compiling"- targetArch <- readSetting "target arch"- targetOS <- readSetting "target os"- targetWordSize <- readSetting "target word size"- targetUnregisterised <- getBooleanSetting "Unregisterised"- targetHasGnuNonexecStack <- readSetting "target has GNU nonexec stack"- targetHasIdentDirective <- readSetting "target has .ident directive"- targetHasSubsectionsViaSymbols <- readSetting "target has subsections via symbols"- myExtraGccViaCFlags <- getSetting "GCC extra via C opts"- -- On Windows, mingw is distributed with GHC,- -- so we look in TopDir/../mingw/bin- -- It would perhaps be nice to be able to override this- -- with the settings file, but it would be a little fiddly- -- to make that possible, so for now you can't.- gcc_prog <- getSetting "C compiler command"- gcc_args_str <- getSetting "C compiler flags"- gccSupportsNoPie <- getBooleanSetting "C compiler supports -no-pie"- cpp_prog <- getSetting "Haskell CPP command"- cpp_args_str <- getSetting "Haskell CPP flags"- let unreg_gcc_args = if targetUnregisterised- then ["-DNO_REGS", "-DUSE_MINIINTERPRETER"]- else []- -- TABLES_NEXT_TO_CODE affects the info table layout.- tntc_gcc_args- | mkTablesNextToCode targetUnregisterised- = ["-DTABLES_NEXT_TO_CODE"]- | otherwise = []- cpp_args= map Option (words cpp_args_str)- gcc_args = map Option (words gcc_args_str- ++ unreg_gcc_args- ++ tntc_gcc_args)- ldSupportsCompactUnwind <- getBooleanSetting "ld supports compact unwind"- ldSupportsBuildId <- getBooleanSetting "ld supports build-id"- ldSupportsFilelist <- getBooleanSetting "ld supports filelist"- ldIsGnuLd <- getBooleanSetting "ld is GNU ld"- perl_path <- getSetting "perl command"-- let pkgconfig_path = installed "package.conf.d"- ghc_usage_msg_path = installed "ghc-usage.txt"- ghci_usage_msg_path = installed "ghci-usage.txt"-- -- For all systems, unlit, split, mangle are GHC utilities- -- architecture-specific stuff is done when building Config.hs- unlit_path = libexec cGHC_UNLIT_PGM-- -- split is a Perl script- split_script = libexec cGHC_SPLIT_PGM-- windres_path <- getSetting "windres command"- libtool_path <- getSetting "libtool command"-- tmpdir <- getTemporaryDirectory-- touch_path <- getSetting "touch command"-- let -- On Win32 we don't want to rely on #!/bin/perl, so we prepend- -- a call to Perl to get the invocation of split.- -- On Unix, scripts are invoked using the '#!' method. Binary- -- installations of GHC on Unix place the correct line on the- -- front of the script at installation time, so we don't want- -- to wire-in our knowledge of $(PERL) on the host system here.- (split_prog, split_args)- | isWindowsHost = (perl_path, [Option split_script])- | otherwise = (split_script, [])- mkdll_prog <- getSetting "dllwrap command"- let mkdll_args = []-- -- cpp is derived from gcc on all platforms- -- HACK, see setPgmP below. We keep 'words' here to remember to fix- -- Config.hs one day.--- -- Other things being equal, as and ld are simply gcc- gcc_link_args_str <- getSetting "C compiler link flags"- let as_prog = gcc_prog- as_args = gcc_args- ld_prog = gcc_prog- ld_args = gcc_args ++ map Option (words gcc_link_args_str)-- -- We just assume on command line- lc_prog <- getSetting "LLVM llc command"- lo_prog <- getSetting "LLVM opt command"-- let iserv_prog = libexec "ghc-iserv"-- let platform = Platform {- platformArch = targetArch,- platformOS = targetOS,- platformWordSize = targetWordSize,- platformUnregisterised = targetUnregisterised,- platformHasGnuNonexecStack = targetHasGnuNonexecStack,- platformHasIdentDirective = targetHasIdentDirective,- platformHasSubsectionsViaSymbols = targetHasSubsectionsViaSymbols,- platformIsCrossCompiling = crossCompiling- }-- return $ Settings {- sTargetPlatform = platform,- sTmpDir = normalise tmpdir,- sGhcUsagePath = ghc_usage_msg_path,- sGhciUsagePath = ghci_usage_msg_path,- sTopDir = top_dir,- sRawSettings = mySettings,- sExtraGccViaCFlags = words myExtraGccViaCFlags,- sSystemPackageConfig = pkgconfig_path,- sLdSupportsCompactUnwind = ldSupportsCompactUnwind,- sLdSupportsBuildId = ldSupportsBuildId,- sLdSupportsFilelist = ldSupportsFilelist,- sLdIsGnuLd = ldIsGnuLd,- sGccSupportsNoPie = gccSupportsNoPie,- sProgramName = "ghc",- sProjectVersion = cProjectVersion,- sPgm_L = unlit_path,- sPgm_P = (cpp_prog, cpp_args),- sPgm_F = "",- sPgm_c = (gcc_prog, gcc_args),- sPgm_s = (split_prog,split_args),- sPgm_a = (as_prog, as_args),- sPgm_l = (ld_prog, ld_args),- sPgm_dll = (mkdll_prog,mkdll_args),- sPgm_T = touch_path,- sPgm_windres = windres_path,- sPgm_libtool = libtool_path,- sPgm_lo = (lo_prog,[]),- sPgm_lc = (lc_prog,[]),- sPgm_i = iserv_prog,- sOpt_L = [],- sOpt_P = [],- sOpt_F = [],- sOpt_c = [],- sOpt_a = [],- sOpt_l = [],- sOpt_windres = [],- sOpt_lo = [],- sOpt_lc = [],- sOpt_i = [],- sPlatformConstants = platformConstants- }---- returns a Unix-format path (relying on getBaseDir to do so too)-findTopDir :: Maybe String -- Maybe TopDir path (without the '-B' prefix).- -> IO String -- TopDir (in Unix format '/' separated)-findTopDir (Just minusb) = return (normalise minusb)-findTopDir Nothing- = do -- Get directory of executable- maybe_exec_dir <- getBaseDir- case maybe_exec_dir of- -- "Just" on Windows, "Nothing" on unix- Nothing -> throwGhcExceptionIO (InstallationError "missing -B<dir> option")- Just dir -> return dir--{--************************************************************************-* *-\subsection{Running an external program}-* *-************************************************************************--}--runUnlit :: DynFlags -> [Option] -> IO ()-runUnlit dflags args = do- let prog = pgm_L dflags- opts = getOpts dflags opt_L- runSomething dflags "Literate pre-processor" prog- (map Option opts ++ args)--runCpp :: DynFlags -> [Option] -> IO ()-runCpp dflags args = do- let (p,args0) = pgm_P dflags- args1 = map Option (getOpts dflags opt_P)- args2 = [Option "-Werror" | gopt Opt_WarnIsError dflags]- ++ [Option "-Wundef" | wopt Opt_WarnCPPUndef dflags]- mb_env <- getGccEnv args2- runSomethingFiltered dflags id "C pre-processor" p- (args0 ++ args1 ++ args2 ++ args) mb_env--runPp :: DynFlags -> [Option] -> IO ()-runPp dflags args = do- let prog = pgm_F dflags- opts = map Option (getOpts dflags opt_F)- runSomething dflags "Haskell pre-processor" prog (args ++ opts)--runCc :: DynFlags -> [Option] -> IO ()-runCc dflags args = do- let (p,args0) = pgm_c dflags- args1 = map Option (getOpts dflags opt_c)- args2 = args0 ++ args1 ++ args- mb_env <- getGccEnv args2- runSomethingResponseFile dflags cc_filter "C Compiler" p args2 mb_env- where- -- discard some harmless warnings from gcc that we can't turn off- cc_filter = unlines . doFilter . lines-- {-- gcc gives warnings in chunks like so:- In file included from /foo/bar/baz.h:11,- from /foo/bar/baz2.h:22,- from wibble.c:33:- /foo/flibble:14: global register variable ...- /foo/flibble:15: warning: call-clobbered r...- We break it up into its chunks, remove any call-clobbered register- warnings from each chunk, and then delete any chunks that we have- emptied of warnings.- -}- doFilter = unChunkWarnings . filterWarnings . chunkWarnings []- -- We can't assume that the output will start with an "In file inc..."- -- line, so we start off expecting a list of warnings rather than a- -- location stack.- chunkWarnings :: [String] -- The location stack to use for the next- -- list of warnings- -> [String] -- The remaining lines to look at- -> [([String], [String])]- chunkWarnings loc_stack [] = [(loc_stack, [])]- chunkWarnings loc_stack xs- = case break loc_stack_start xs of- (warnings, lss:xs') ->- case span loc_start_continuation xs' of- (lsc, xs'') ->- (loc_stack, warnings) : chunkWarnings (lss : lsc) xs''- _ -> [(loc_stack, xs)]-- filterWarnings :: [([String], [String])] -> [([String], [String])]- filterWarnings [] = []- -- If the warnings are already empty then we are probably doing- -- something wrong, so don't delete anything- filterWarnings ((xs, []) : zs) = (xs, []) : filterWarnings zs- filterWarnings ((xs, ys) : zs) = case filter wantedWarning ys of- [] -> filterWarnings zs- ys' -> (xs, ys') : filterWarnings zs-- unChunkWarnings :: [([String], [String])] -> [String]- unChunkWarnings [] = []- unChunkWarnings ((xs, ys) : zs) = xs ++ ys ++ unChunkWarnings zs-- loc_stack_start s = "In file included from " `isPrefixOf` s- loc_start_continuation s = " from " `isPrefixOf` s- wantedWarning w- | "warning: call-clobbered register used" `isContainedIn` w = False- | otherwise = True--isContainedIn :: String -> String -> Bool-xs `isContainedIn` ys = any (xs `isPrefixOf`) (tails ys)---- | Run the linker with some arguments and return the output-askLd :: DynFlags -> [Option] -> IO String-askLd dflags args = do- let (p,args0) = pgm_l dflags- args1 = map Option (getOpts dflags opt_l)- args2 = args0 ++ args1 ++ args- mb_env <- getGccEnv args2- runSomethingWith dflags "gcc" p args2 $ \real_args ->- readCreateProcessWithExitCode' (proc p real_args){ env = mb_env }---- Similar to System.Process.readCreateProcessWithExitCode, but stderr is--- inherited from the parent process, and output to stderr is not captured.-readCreateProcessWithExitCode'- :: CreateProcess- -> IO (ExitCode, String) -- ^ stdout-readCreateProcessWithExitCode' proc = do- (_, Just outh, _, pid) <-- createProcess proc{ std_out = CreatePipe }-- -- fork off a thread to start consuming the output- output <- hGetContents outh- outMVar <- newEmptyMVar- _ <- forkIO $ evaluate (length output) >> putMVar outMVar ()-- -- wait on the output- takeMVar outMVar- hClose outh-- -- wait on the process- ex <- waitForProcess pid-- return (ex, output)--replaceVar :: (String, String) -> [(String, String)] -> [(String, String)]-replaceVar (var, value) env =- (var, value) : filter (\(var',_) -> var /= var') env---- | Version of @System.Process.readProcessWithExitCode@ that takes a--- key-value tuple to insert into the environment.-readProcessEnvWithExitCode- :: String -- ^ program path- -> [String] -- ^ program args- -> (String, String) -- ^ addition to the environment- -> IO (ExitCode, String, String) -- ^ (exit_code, stdout, stderr)-readProcessEnvWithExitCode prog args env_update = do- current_env <- getEnvironment- readCreateProcessWithExitCode (proc prog args) {- env = Just (replaceVar env_update current_env) } ""---- Don't let gcc localize version info string, #8825-c_locale_env :: (String, String)-c_locale_env = ("LANGUAGE", "C")---- If the -B<dir> option is set, add <dir> to PATH. This works around--- a bug in gcc on Windows Vista where it can't find its auxiliary--- binaries (see bug #1110).-getGccEnv :: [Option] -> IO (Maybe [(String,String)])-getGccEnv opts =- if null b_dirs- then return Nothing- else do env <- getEnvironment- return (Just (map mangle_path env))- where- (b_dirs, _) = partitionWith get_b_opt opts-- get_b_opt (Option ('-':'B':dir)) = Left dir- get_b_opt other = Right other-- mangle_path (path,paths) | map toUpper path == "PATH"- = (path, '\"' : head b_dirs ++ "\";" ++ paths)- mangle_path other = other--runSplit :: DynFlags -> [Option] -> IO ()-runSplit dflags args = do- let (p,args0) = pgm_s dflags- runSomething dflags "Splitter" p (args0++args)--runAs :: DynFlags -> [Option] -> IO ()-runAs dflags args = do- let (p,args0) = pgm_a dflags- args1 = map Option (getOpts dflags opt_a)- args2 = args0 ++ args1 ++ args- mb_env <- getGccEnv args2- runSomethingFiltered dflags id "Assembler" p args2 mb_env---- | Run the LLVM Optimiser-runLlvmOpt :: DynFlags -> [Option] -> IO ()-runLlvmOpt dflags args = do- let (p,args0) = pgm_lo dflags- args1 = map Option (getOpts dflags opt_lo)- runSomething dflags "LLVM Optimiser" p (args0 ++ args1 ++ args)---- | Run the LLVM Compiler-runLlvmLlc :: DynFlags -> [Option] -> IO ()-runLlvmLlc dflags args = do- let (p,args0) = pgm_lc dflags- args1 = map Option (getOpts dflags opt_lc)- runSomething dflags "LLVM Compiler" p (args0 ++ args1 ++ args)---- | Run the clang compiler (used as an assembler for the LLVM--- backend on OS X as LLVM doesn't support the OS X system--- assembler)-runClang :: DynFlags -> [Option] -> IO ()-runClang dflags args = do- -- we simply assume its available on the PATH- let clang = "clang"- -- be careful what options we call clang with- -- see #5903 and #7617 for bugs caused by this.- (_,args0) = pgm_a dflags- args1 = map Option (getOpts dflags opt_a)- args2 = args0 ++ args1 ++ args- mb_env <- getGccEnv args2- Exception.catch (do- runSomethingFiltered dflags id "Clang (Assembler)" clang args2 mb_env- )- (\(err :: SomeException) -> do- errorMsg dflags $- text ("Error running clang! you need clang installed to use the" ++- " LLVM backend") $+$- text "(or GHC tried to execute clang incorrectly)"- throwIO err- )---- | Figure out which version of LLVM we are running this session-figureLlvmVersion :: DynFlags -> IO (Maybe (Int, Int))-figureLlvmVersion dflags = do- let (pgm,opts) = pgm_lc dflags- args = filter notNull (map showOpt opts)- -- we grab the args even though they should be useless just in- -- case the user is using a customised 'llc' that requires some- -- of the options they've specified. llc doesn't care what other- -- options are specified when '-version' is used.- args' = args ++ ["-version"]- ver <- catchIO (do- (pin, pout, perr, _) <- runInteractiveProcess pgm args'- Nothing Nothing- {- > llc -version- LLVM (http://llvm.org/):- LLVM version 3.5.2- ...- -}- hSetBinaryMode pout False- _ <- hGetLine pout- vline <- dropWhile (not . isDigit) `fmap` hGetLine pout- v <- case span (/= '.') vline of- ("",_) -> fail "no digits!"- (x,y) -> return (read x- , read $ takeWhile isDigit $ drop 1 y)-- hClose pin- hClose pout- hClose perr- return $ Just v- )- (\err -> do- debugTraceMsg dflags 2- (text "Error (figuring out LLVM version):" <+>- text (show err))- errorMsg dflags $ vcat- [ text "Warning:", nest 9 $- text "Couldn't figure out LLVM version!" $$- text ("Make sure you have installed LLVM " ++- llvmVersionStr supportedLlvmVersion) ]- return Nothing)- return ver--{- Note [Windows stack usage]--See: Trac #8870 (and #8834 for related info) and #12186--On Windows, occasionally we need to grow the stack. In order to do-this, we would normally just bump the stack pointer - but there's a-catch on Windows.--If the stack pointer is bumped by more than a single page, then the-pages between the initial pointer and the resulting location must be-properly committed by the Windows virtual memory subsystem. This is-only needed in the event we bump by more than one page (i.e 4097 bytes-or more).--Windows compilers solve this by emitting a call to a special function-called _chkstk, which does this committing of the pages for you.--The reason this was causing a segfault was because due to the fact the-new code generator tends to generate larger functions, we needed more-stack space in GHC itself. In the x86 codegen, we needed approximately-~12kb of stack space in one go, which caused the process to segfault,-as the intervening pages were not committed.--GCC can emit such a check for us automatically but only when the flag--fstack-check is used.--See https://gcc.gnu.org/onlinedocs/gnat_ugn/Stack-Overflow-Checking.html-for more information.---}--{- Note [Run-time linker info]--See also: Trac #5240, Trac #6063, Trac #10110--Before 'runLink', we need to be sure to get the relevant information-about the linker we're using at runtime to see if we need any extra-options. For example, GNU ld requires '--reduce-memory-overheads' and-'--hash-size=31' in order to use reasonable amounts of memory (see-trac #5240.) But this isn't supported in GNU gold.--Generally, the linker changing from what was detected at ./configure-time has always been possible using -pgml, but on Linux it can happen-'transparently' by installing packages like binutils-gold, which-change what /usr/bin/ld actually points to.--Clang vs GCC notes:--For gcc, 'gcc -Wl,--version' gives a bunch of output about how to-invoke the linker before the version information string. For 'clang',-the version information for 'ld' is all that's output. For this-reason, we typically need to slurp up all of the standard error output-and look through it.--Other notes:--We cache the LinkerInfo inside DynFlags, since clients may link-multiple times. The definition of LinkerInfo is there to avoid a-circular dependency.---}--{- Note [ELF needed shared libs]--Some distributions change the link editor's default handling of-ELF DT_NEEDED tags to include only those shared objects that are-needed to resolve undefined symbols. For Template Haskell we need-the last temporary shared library also if it is not needed for the-currently linked temporary shared library. We specify --no-as-needed-to override the default. This flag exists in GNU ld and GNU gold.--The flag is only needed on ELF systems. On Windows (PE) and Mac OS X-(Mach-O) the flag is not needed.---}--{- Note [Windows static libGCC]--The GCC versions being upgraded to in #10726 are configured with-dynamic linking of libgcc supported. This results in libgcc being-linked dynamically when a shared library is created.--This introduces thus an extra dependency on GCC dll that was not-needed before by shared libraries created with GHC. This is a particular-issue on Windows because you get a non-obvious error due to this missing-dependency. This dependent dll is also not commonly on your path.--For this reason using the static libgcc is preferred as it preserves-the same behaviour that existed before. There are however some very good-reasons to have the shared version as well as described on page 181 of-https://gcc.gnu.org/onlinedocs/gcc-5.2.0/gcc.pdf :--"There are several situations in which an application should use the- shared ‘libgcc’ instead of the static version. The most common of these- is when the application wishes to throw and catch exceptions across different- shared libraries. In that case, each of the libraries as well as the application- itself should use the shared ‘libgcc’. "---}--neededLinkArgs :: LinkerInfo -> [Option]-neededLinkArgs (GnuLD o) = o-neededLinkArgs (GnuGold o) = o-neededLinkArgs (DarwinLD o) = o-neededLinkArgs (SolarisLD o) = o-neededLinkArgs (AixLD o) = o-neededLinkArgs UnknownLD = []---- Grab linker info and cache it in DynFlags.-getLinkerInfo :: DynFlags -> IO LinkerInfo-getLinkerInfo dflags = do- info <- readIORef (rtldInfo dflags)- case info of- Just v -> return v- Nothing -> do- v <- getLinkerInfo' dflags- writeIORef (rtldInfo dflags) (Just v)- return v---- See Note [Run-time linker info].-getLinkerInfo' :: DynFlags -> IO LinkerInfo-getLinkerInfo' dflags = do- let platform = targetPlatform dflags- os = platformOS platform- (pgm,args0) = pgm_l dflags- args1 = map Option (getOpts dflags opt_l)- args2 = args0 ++ args1- args3 = filter notNull (map showOpt args2)-- -- Try to grab the info from the process output.- parseLinkerInfo stdo _stde _exitc- | any ("GNU ld" `isPrefixOf`) stdo =- -- GNU ld specifically needs to use less memory. This especially- -- hurts on small object files. Trac #5240.- -- Set DT_NEEDED for all shared libraries. Trac #10110.- -- TODO: Investigate if these help or hurt when using split sections.- return (GnuLD $ map Option ["-Wl,--hash-size=31",- "-Wl,--reduce-memory-overheads",- -- ELF specific flag- -- see Note [ELF needed shared libs]- "-Wl,--no-as-needed"])-- | any ("GNU gold" `isPrefixOf`) stdo =- -- GNU gold only needs --no-as-needed. Trac #10110.- -- ELF specific flag, see Note [ELF needed shared libs]- return (GnuGold [Option "-Wl,--no-as-needed"])-- -- Unknown linker.- | otherwise = fail "invalid --version output, or linker is unsupported"-- -- Process the executable call- info <- catchIO (do- case os of- OSSolaris2 ->- -- Solaris uses its own Solaris linker. Even all- -- GNU C are recommended to configure with Solaris- -- linker instead of using GNU binutils linker. Also- -- all GCC distributed with Solaris follows this rule- -- precisely so we assume here, the Solaris linker is- -- used.- return $ SolarisLD []- OSAIX ->- -- IBM AIX uses its own non-binutils linker as well- return $ AixLD []- OSDarwin ->- -- Darwin has neither GNU Gold or GNU LD, but a strange linker- -- that doesn't support --version. We can just assume that's- -- what we're using.- return $ DarwinLD []- OSiOS ->- -- Ditto for iOS- return $ DarwinLD []- OSMinGW32 ->- -- GHC doesn't support anything but GNU ld on Windows anyway.- -- Process creation is also fairly expensive on win32, so- -- we short-circuit here.- return $ GnuLD $ map Option- [ -- Reduce ld memory usage- "-Wl,--hash-size=31"- , "-Wl,--reduce-memory-overheads"- -- Emit gcc stack checks- -- Note [Windows stack usage]- , "-fstack-check"- -- Force static linking of libGCC- -- Note [Windows static libGCC]- , "-static-libgcc" ]- _ -> do- -- In practice, we use the compiler as the linker here. Pass- -- -Wl,--version to get linker version info.- (exitc, stdo, stde) <- readProcessEnvWithExitCode pgm- (["-Wl,--version"] ++ args3)- c_locale_env- -- Split the output by lines to make certain kinds- -- of processing easier. In particular, 'clang' and 'gcc'- -- have slightly different outputs for '-Wl,--version', but- -- it's still easy to figure out.- parseLinkerInfo (lines stdo) (lines stde) exitc- )- (\err -> do- debugTraceMsg dflags 2- (text "Error (figuring out linker information):" <+>- text (show err))- errorMsg dflags $ hang (text "Warning:") 9 $- text "Couldn't figure out linker information!" $$- text "Make sure you're using GNU ld, GNU gold" <+>- text "or the built in OS X linker, etc."- return UnknownLD)- return info---- Grab compiler info and cache it in DynFlags.-getCompilerInfo :: DynFlags -> IO CompilerInfo-getCompilerInfo dflags = do- info <- readIORef (rtccInfo dflags)- case info of- Just v -> return v- Nothing -> do- v <- getCompilerInfo' dflags- writeIORef (rtccInfo dflags) (Just v)- return v---- See Note [Run-time linker info].-getCompilerInfo' :: DynFlags -> IO CompilerInfo-getCompilerInfo' dflags = do- let (pgm,_) = pgm_c dflags- -- Try to grab the info from the process output.- parseCompilerInfo _stdo stde _exitc- -- Regular GCC- | any ("gcc version" `isInfixOf`) stde =- return GCC- -- Regular clang- | any ("clang version" `isInfixOf`) stde =- return Clang- -- XCode 5.1 clang- | any ("Apple LLVM version 5.1" `isPrefixOf`) stde =- return AppleClang51- -- XCode 5 clang- | any ("Apple LLVM version" `isPrefixOf`) stde =- return AppleClang- -- XCode 4.1 clang- | any ("Apple clang version" `isPrefixOf`) stde =- return AppleClang- -- Unknown linker.- | otherwise = fail "invalid -v output, or compiler is unsupported"-- -- Process the executable call- info <- catchIO (do- (exitc, stdo, stde) <-- readProcessEnvWithExitCode pgm ["-v"] c_locale_env- -- Split the output by lines to make certain kinds- -- of processing easier.- parseCompilerInfo (lines stdo) (lines stde) exitc- )- (\err -> do- debugTraceMsg dflags 2- (text "Error (figuring out C compiler information):" <+>- text (show err))- errorMsg dflags $ hang (text "Warning:") 9 $- text "Couldn't figure out C compiler information!" $$- text "Make sure you're using GNU gcc, or clang"- return UnknownCC)- return info--runLink :: DynFlags -> [Option] -> IO ()-runLink dflags args = do- -- See Note [Run-time linker info]- linkargs <- neededLinkArgs `fmap` getLinkerInfo dflags- let (p,args0) = pgm_l dflags- args1 = map Option (getOpts dflags opt_l)- args2 = args0 ++ linkargs ++ args1 ++ args- mb_env <- getGccEnv args2- runSomethingResponseFile dflags ld_filter "Linker" p args2 mb_env- where- ld_filter = case (platformOS (targetPlatform dflags)) of- OSSolaris2 -> sunos_ld_filter- _ -> id-{-- SunOS/Solaris ld emits harmless warning messages about unresolved- symbols in case of compiling into shared library when we do not- link against all the required libs. That is the case of GHC which- does not link against RTS library explicitly in order to be able to- choose the library later based on binary application linking- parameters. The warnings look like:--Undefined first referenced- symbol in file-stg_ap_n_fast ./T2386_Lib.o-stg_upd_frame_info ./T2386_Lib.o-templatezmhaskell_LanguageziHaskellziTHziLib_litE_closure ./T2386_Lib.o-templatezmhaskell_LanguageziHaskellziTHziLib_appE_closure ./T2386_Lib.o-templatezmhaskell_LanguageziHaskellziTHziLib_conE_closure ./T2386_Lib.o-templatezmhaskell_LanguageziHaskellziTHziSyntax_mkNameGzud_closure ./T2386_Lib.o-newCAF ./T2386_Lib.o-stg_bh_upd_frame_info ./T2386_Lib.o-stg_ap_ppp_fast ./T2386_Lib.o-templatezmhaskell_LanguageziHaskellziTHziLib_stringL_closure ./T2386_Lib.o-stg_ap_p_fast ./T2386_Lib.o-stg_ap_pp_fast ./T2386_Lib.o-ld: warning: symbol referencing errors-- this is actually coming from T2386 testcase. The emitting of those- warnings is also a reason why so many TH testcases fail on Solaris.-- Following filter code is SunOS/Solaris linker specific and should- filter out only linker warnings. Please note that the logic is a- little bit more complex due to the simple reason that we need to preserve- any other linker emitted messages. If there are any. Simply speaking- if we see "Undefined" and later "ld: warning:..." then we omit all- text between (including) the marks. Otherwise we copy the whole output.--}- sunos_ld_filter :: String -> String- sunos_ld_filter = unlines . sunos_ld_filter' . lines- sunos_ld_filter' x = if (undefined_found x && ld_warning_found x)- then (ld_prefix x) ++ (ld_postfix x)- else x- breakStartsWith x y = break (isPrefixOf x) y- ld_prefix = fst . breakStartsWith "Undefined"- undefined_found = not . null . snd . breakStartsWith "Undefined"- ld_warn_break = breakStartsWith "ld: warning: symbol referencing errors"- ld_postfix = tail . snd . ld_warn_break- ld_warning_found = not . null . snd . ld_warn_break---runLibtool :: DynFlags -> [Option] -> IO ()-runLibtool dflags args = do- linkargs <- neededLinkArgs `fmap` getLinkerInfo dflags- let args1 = map Option (getOpts dflags opt_l)- args2 = [Option "-static"] ++ args1 ++ args ++ linkargs- libtool = pgm_libtool dflags- mb_env <- getGccEnv args2- runSomethingFiltered dflags id "Linker" libtool args2 mb_env--runMkDLL :: DynFlags -> [Option] -> IO ()-runMkDLL dflags args = do- let (p,args0) = pgm_dll dflags- args1 = args0 ++ args- mb_env <- getGccEnv (args0++args)- runSomethingFiltered dflags id "Make DLL" p args1 mb_env--runWindres :: DynFlags -> [Option] -> IO ()-runWindres dflags args = do- let (gcc, gcc_args) = pgm_c dflags- windres = pgm_windres dflags- opts = map Option (getOpts dflags opt_windres)- quote x = "\"" ++ x ++ "\""- args' = -- If windres.exe and gcc.exe are in a directory containing- -- spaces then windres fails to run gcc. We therefore need- -- to tell it what command to use...- Option ("--preprocessor=" ++- unwords (map quote (gcc :- map showOpt gcc_args ++- map showOpt opts ++- ["-E", "-xc", "-DRC_INVOKED"])))- -- ...but if we do that then if windres calls popen then- -- it can't understand the quoting, so we have to use- -- --use-temp-file so that it interprets it correctly.- -- See #1828.- : Option "--use-temp-file"- : args- mb_env <- getGccEnv gcc_args- runSomethingFiltered dflags id "Windres" windres args' mb_env--touch :: DynFlags -> String -> String -> IO ()-touch dflags purpose arg =- runSomething dflags purpose (pgm_T dflags) [FileOption "" arg]--copy :: DynFlags -> String -> FilePath -> FilePath -> IO ()-copy dflags purpose from to = copyWithHeader dflags purpose Nothing from to--copyWithHeader :: DynFlags -> String -> Maybe String -> FilePath -> FilePath- -> IO ()-copyWithHeader dflags purpose maybe_header from to = do- showPass dflags purpose-- hout <- openBinaryFile to WriteMode- hin <- openBinaryFile from ReadMode- ls <- hGetContents hin -- inefficient, but it'll do for now. ToDo: speed up- maybe (return ()) (header hout) maybe_header- hPutStr hout ls- hClose hout- hClose hin- where- -- write the header string in UTF-8. The header is something like- -- {-# LINE "foo.hs" #-}- -- and we want to make sure a Unicode filename isn't mangled.- header h str = do- hSetEncoding h utf8- hPutStr h str- hSetBinaryMode h True----{--************************************************************************-* *-\subsection{Managing temporary files-* *-************************************************************************--}--cleanTempDirs :: DynFlags -> IO ()-cleanTempDirs dflags- = unless (gopt Opt_KeepTmpFiles dflags)- $ mask_- $ do let ref = dirsToClean dflags- ds <- atomicModifyIORef' ref $ \ds -> (Map.empty, ds)- removeTmpDirs dflags (Map.elems ds)--cleanTempFiles :: DynFlags -> IO ()-cleanTempFiles dflags- = unless (gopt Opt_KeepTmpFiles dflags)- $ mask_- $ do let ref = filesToClean dflags- fs <- atomicModifyIORef' ref $ \fs -> ([],fs)- removeTmpFiles dflags fs--cleanTempFilesExcept :: DynFlags -> [FilePath] -> IO ()-cleanTempFilesExcept dflags dont_delete- = unless (gopt Opt_KeepTmpFiles dflags)- $ mask_- $ do let ref = filesToClean dflags- to_delete <- atomicModifyIORef' ref $ \files ->- let res@(_to_keep, _to_delete) =- partition (`Set.member` dont_delete_set) files- in res- removeTmpFiles dflags to_delete- where dont_delete_set = Set.fromList dont_delete----- Return a unique numeric temp file suffix-newTempSuffix :: DynFlags -> IO Int-newTempSuffix dflags = atomicModifyIORef' (nextTempSuffix dflags) $ \n -> (n+1,n)---- Find a temporary name that doesn't already exist.-newTempName :: DynFlags -> Suffix -> IO FilePath-newTempName dflags extn- = do d <- getTempDir dflags- findTempName (d </> "ghc_") -- See Note [Deterministic base name]- where- findTempName :: FilePath -> IO FilePath- findTempName prefix- = do n <- newTempSuffix dflags- let filename = prefix ++ show n <.> extn- b <- doesFileExist filename- if b then findTempName prefix- else do -- clean it up later- consIORef (filesToClean dflags) filename- return filename--newTempLibName :: DynFlags -> Suffix -> IO (FilePath, FilePath, String)-newTempLibName dflags extn- = do d <- getTempDir dflags- findTempName d ("ghc_")- where- findTempName :: FilePath -> String -> IO (FilePath, FilePath, String)- findTempName dir prefix- = do n <- newTempSuffix dflags -- See Note [Deterministic base name]- let libname = prefix ++ show n- filename = dir </> "lib" ++ libname <.> extn- b <- doesFileExist filename- if b then findTempName dir prefix- else do -- clean it up later- consIORef (filesToClean dflags) filename- return (filename, dir, libname)----- Return our temporary directory within tmp_dir, creating one if we--- don't have one yet.-getTempDir :: DynFlags -> IO FilePath-getTempDir dflags = do- mapping <- readIORef dir_ref- case Map.lookup tmp_dir mapping of- Nothing -> do- pid <- getProcessID- let prefix = tmp_dir </> "ghc" ++ show pid ++ "_"- mask_ $ mkTempDir prefix- Just dir -> return dir- where- tmp_dir = tmpDir dflags- dir_ref = dirsToClean dflags-- mkTempDir :: FilePath -> IO FilePath- mkTempDir prefix = do- n <- newTempSuffix dflags- let our_dir = prefix ++ show n-- -- 1. Speculatively create our new directory.- createDirectory our_dir-- -- 2. Update the dirsToClean mapping unless an entry already exists- -- (i.e. unless another thread beat us to it).- their_dir <- atomicModifyIORef' dir_ref $ \mapping ->- case Map.lookup tmp_dir mapping of- Just dir -> (mapping, Just dir)- Nothing -> (Map.insert tmp_dir our_dir mapping, Nothing)-- -- 3. If there was an existing entry, return it and delete the- -- directory we created. Otherwise return the directory we created.- case their_dir of- Nothing -> do- debugTraceMsg dflags 2 $- text "Created temporary directory:" <+> text our_dir- return our_dir- Just dir -> do- removeDirectory our_dir- return dir- `catchIO` \e -> if isAlreadyExistsError e- then mkTempDir prefix else ioError e---- Note [Deterministic base name]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ The filename of temporary files, especially the basename of C files, can end--- up in the output in some form, e.g. as part of linker debug information. In the--- interest of bit-wise exactly reproducible compilation (#4012), the basename of--- the temporary file no longer contains random information (it used to contain--- the process id).------ This is ok, as the temporary directory used contains the pid (see getTempDir).--addFilesToClean :: DynFlags -> [FilePath] -> IO ()--- May include wildcards [used by DriverPipeline.run_phase SplitMangle]-addFilesToClean dflags new_files- = atomicModifyIORef' (filesToClean dflags) $ \files -> (new_files++files, ())--removeTmpDirs :: DynFlags -> [FilePath] -> IO ()-removeTmpDirs dflags ds- = traceCmd dflags "Deleting temp dirs"- ("Deleting: " ++ unwords ds)- (mapM_ (removeWith dflags removeDirectory) ds)--removeTmpFiles :: DynFlags -> [FilePath] -> IO ()-removeTmpFiles dflags fs- = warnNon $- traceCmd dflags "Deleting temp files"- ("Deleting: " ++ unwords deletees)- (mapM_ (removeWith dflags removeFile) deletees)- where- -- Flat out refuse to delete files that are likely to be source input- -- files (is there a worse bug than having a compiler delete your source- -- files?)- --- -- Deleting source files is a sign of a bug elsewhere, so prominently flag- -- the condition.- warnNon act- | null non_deletees = act- | otherwise = do- putMsg dflags (text "WARNING - NOT deleting source files:" <+> hsep (map text non_deletees))- act-- (non_deletees, deletees) = partition isHaskellUserSrcFilename fs--removeWith :: DynFlags -> (FilePath -> IO ()) -> FilePath -> IO ()-removeWith dflags remover f = remover f `catchIO`- (\e ->- let msg = if isDoesNotExistError e- then text "Warning: deleting non-existent" <+> text f- else text "Warning: exception raised when deleting"- <+> text f <> colon- $$ text (show e)- in debugTraceMsg dflags 2 msg- )---------------------------------------------------------------------------------- Running an external program--runSomething :: DynFlags- -> String -- For -v message- -> String -- Command name (possibly a full path)- -- assumed already dos-ified- -> [Option] -- Arguments- -- runSomething will dos-ify them- -> IO ()--runSomething dflags phase_name pgm args =- runSomethingFiltered dflags id phase_name pgm args Nothing---- | Run a command, placing the arguments in an external response file.------ This command is used in order to avoid overlong command line arguments on--- Windows. The command line arguments are first written to an external,--- temporary response file, and then passed to the linker via @filepath.--- response files for passing them in. See:------ https://gcc.gnu.org/wiki/Response_Files--- https://ghc.haskell.org/trac/ghc/ticket/10777-runSomethingResponseFile- :: DynFlags -> (String->String) -> String -> String -> [Option]- -> Maybe [(String,String)] -> IO ()--runSomethingResponseFile dflags filter_fn phase_name pgm args mb_env =- runSomethingWith dflags phase_name pgm args $ \real_args -> do- fp <- getResponseFile real_args- let args = ['@':fp]- r <- builderMainLoop dflags filter_fn pgm args mb_env- return (r,())- where- getResponseFile args = do- fp <- newTempName dflags "rsp"- withFile fp WriteMode $ \h -> do-#if defined(mingw32_HOST_OS)- hSetEncoding h latin1-#else- hSetEncoding h utf8-#endif- hPutStr h $ unlines $ map escape args- return fp-- -- Note: Response files have backslash-escaping, double quoting, and are- -- whitespace separated (some implementations use newline, others any- -- whitespace character). Therefore, escape any backslashes, newlines, and- -- double quotes in the argument, and surround the content with double- -- quotes.- --- -- Another possibility that could be considered would be to convert- -- backslashes in the argument to forward slashes. This would generally do- -- the right thing, since backslashes in general only appear in arguments- -- as part of file paths on Windows, and the forward slash is accepted for- -- those. However, escaping is more reliable, in case somehow a backslash- -- appears in a non-file.- escape x = concat- [ "\""- , concatMap- (\c ->- case c of- '\\' -> "\\\\"- '\n' -> "\\n"- '\"' -> "\\\""- _ -> [c])- x- , "\""- ]--runSomethingFiltered- :: DynFlags -> (String->String) -> String -> String -> [Option]- -> Maybe [(String,String)] -> IO ()--runSomethingFiltered dflags filter_fn phase_name pgm args mb_env = do- runSomethingWith dflags phase_name pgm args $ \real_args -> do- r <- builderMainLoop dflags filter_fn pgm real_args mb_env- return (r,())--runSomethingWith- :: DynFlags -> String -> String -> [Option]- -> ([String] -> IO (ExitCode, a))- -> IO a--runSomethingWith dflags phase_name pgm args io = do- let real_args = filter notNull (map showOpt args)- cmdLine = showCommandForUser pgm real_args- traceCmd dflags phase_name cmdLine $ handleProc pgm phase_name $ io real_args--handleProc :: String -> String -> IO (ExitCode, r) -> IO r-handleProc pgm phase_name proc = do- (rc, r) <- proc `catchIO` handler- case rc of- ExitSuccess{} -> return r- ExitFailure n -> throwGhcExceptionIO (- ProgramError ("`" ++ takeFileName pgm ++ "'" ++- " failed in phase `" ++ phase_name ++ "'." ++- " (Exit code: " ++ show n ++ ")"))- where- handler err =- if IO.isDoesNotExistError err- then does_not_exist- else throwGhcExceptionIO (ProgramError $ show err)-- does_not_exist = throwGhcExceptionIO (InstallationError ("could not execute: " ++ pgm))---builderMainLoop :: DynFlags -> (String -> String) -> FilePath- -> [String] -> Maybe [(String, String)]- -> IO ExitCode-builderMainLoop dflags filter_fn pgm real_args mb_env = do- chan <- newChan- (hStdIn, hStdOut, hStdErr, hProcess) <- runInteractiveProcess pgm real_args Nothing mb_env-- -- and run a loop piping the output from the compiler to the log_action in DynFlags- hSetBuffering hStdOut LineBuffering- hSetBuffering hStdErr LineBuffering- _ <- forkIO (readerProc chan hStdOut filter_fn)- _ <- forkIO (readerProc chan hStdErr filter_fn)- -- we don't want to finish until 2 streams have been completed- -- (stdout and stderr)- -- nor until 1 exit code has been retrieved.- rc <- loop chan hProcess (2::Integer) (1::Integer) ExitSuccess- -- after that, we're done here.- hClose hStdIn- hClose hStdOut- hClose hStdErr- return rc- where- -- status starts at zero, and increments each time either- -- a reader process gets EOF, or the build proc exits. We wait- -- for all of these to happen (status==3).- -- ToDo: we should really have a contingency plan in case any of- -- the threads dies, such as a timeout.- loop _ _ 0 0 exitcode = return exitcode- loop chan hProcess t p exitcode = do- mb_code <- if p > 0- then getProcessExitCode hProcess- else return Nothing- case mb_code of- Just code -> loop chan hProcess t (p-1) code- Nothing- | t > 0 -> do- msg <- readChan chan- case msg of- BuildMsg msg -> do- putLogMsg dflags NoReason SevInfo noSrcSpan- (defaultUserStyle dflags) msg- loop chan hProcess t p exitcode- BuildError loc msg -> do- putLogMsg dflags NoReason SevError (mkSrcSpan loc loc)- (defaultUserStyle dflags) msg- loop chan hProcess t p exitcode- EOF ->- loop chan hProcess (t-1) p exitcode- | otherwise -> loop chan hProcess t p exitcode--readerProc :: Chan BuildMessage -> Handle -> (String -> String) -> IO ()-readerProc chan hdl filter_fn =- (do str <- hGetContents hdl- loop (linesPlatform (filter_fn str)) Nothing)- `finally`- writeChan chan EOF- -- ToDo: check errors more carefully- -- ToDo: in the future, the filter should be implemented as- -- a stream transformer.- where- loop [] Nothing = return ()- loop [] (Just err) = writeChan chan err- loop (l:ls) in_err =- case in_err of- Just err@(BuildError srcLoc msg)- | leading_whitespace l -> do- loop ls (Just (BuildError srcLoc (msg $$ text l)))- | otherwise -> do- writeChan chan err- checkError l ls- Nothing -> do- checkError l ls- _ -> panic "readerProc/loop"-- checkError l ls- = case parseError l of- Nothing -> do- writeChan chan (BuildMsg (text l))- loop ls Nothing- Just (file, lineNum, colNum, msg) -> do- let srcLoc = mkSrcLoc (mkFastString file) lineNum colNum- loop ls (Just (BuildError srcLoc (text msg)))-- leading_whitespace [] = False- leading_whitespace (x:_) = isSpace x--parseError :: String -> Maybe (String, Int, Int, String)-parseError s0 = case breakColon s0 of- Just (filename, s1) ->- case breakIntColon s1 of- Just (lineNum, s2) ->- case breakIntColon s2 of- Just (columnNum, s3) ->- Just (filename, lineNum, columnNum, s3)- Nothing ->- Just (filename, lineNum, 0, s2)- Nothing -> Nothing- Nothing -> Nothing--breakColon :: String -> Maybe (String, String)-breakColon xs = case break (':' ==) xs of- (ys, _:zs) -> Just (ys, zs)- _ -> Nothing--breakIntColon :: String -> Maybe (Int, String)-breakIntColon xs = case break (':' ==) xs of- (ys, _:zs)- | not (null ys) && all isAscii ys && all isDigit ys ->- Just (read ys, zs)- _ -> Nothing--data BuildMessage- = BuildMsg !SDoc- | BuildError !SrcLoc !SDoc- | EOF--traceCmd :: DynFlags -> String -> String -> IO a -> IO a--- trace the command (at two levels of verbosity)-traceCmd dflags phase_name cmd_line action- = do { let verb = verbosity dflags- ; showPass dflags phase_name- ; debugTraceMsg dflags 3 (text cmd_line)- ; case flushErr dflags of- FlushErr io -> io-- -- And run it!- ; action `catchIO` handle_exn verb- }- where- handle_exn _verb exn = do { debugTraceMsg dflags 2 (char '\n')- ; debugTraceMsg dflags 2 (text "Failed:" <+> text cmd_line <+> text (show exn))- ; throwGhcExceptionIO (ProgramError (show exn))}--{--************************************************************************-* *-\subsection{Support code}-* *-************************************************************************--}---------------------------------------------------------------------------------- Define getBaseDir :: IO (Maybe String)--getBaseDir :: IO (Maybe String)-#if defined(mingw32_HOST_OS)--- Assuming we are running ghc, accessed by path $(stuff)/<foo>/ghc.exe,--- return the path $(stuff)/lib.-getBaseDir = try_size 2048 -- plenty, PATH_MAX is 512 under Win32.- where- try_size size = allocaArray (fromIntegral size) $ \buf -> do- ret <- c_GetModuleFileName nullPtr buf size- case ret of- 0 -> return Nothing- _ | ret < size -> do- path <- peekCWString buf- real <- getFinalPath path -- try to resolve symlinks paths- let libdir = (rootDir . sanitize . maybe path id) real- exists <- doesDirectoryExist libdir- if exists- then return $ Just libdir- else fail path- | otherwise -> try_size (size * 2)-- -- getFinalPath returns paths in full raw form.- -- Unfortunately GHC isn't set up to handle these- -- So if the call succeeded, we need to drop the- -- \\?\ prefix.- sanitize s = if "\\\\?\\" `isPrefixOf` s- then drop 4 s- else s-- rootDir s = case splitFileName $ normalise s of- (d, ghc_exe)- | lower ghc_exe `elem` ["ghc.exe",- "ghc-stage1.exe",- "ghc-stage2.exe",- "ghc-stage3.exe"] ->- case splitFileName $ takeDirectory d of- -- ghc is in $topdir/bin/ghc.exe- (d', _) -> takeDirectory d' </> "lib"- _ -> fail s-- fail s = panic ("can't decompose ghc.exe path: " ++ show s)- lower = map toLower--foreign import WINDOWS_CCONV unsafe "windows.h GetModuleFileNameW"- c_GetModuleFileName :: Ptr () -> CWString -> Word32 -> IO Word32---- Attempt to resolve symlinks in order to find the actual location GHC--- is located at. See Trac #11759.-getFinalPath :: FilePath -> IO (Maybe FilePath)-getFinalPath name = do- dllHwnd <- failIfNull "LoadLibray" $ loadLibrary "kernel32.dll"- -- Note: The API GetFinalPathNameByHandleW is only available starting from Windows Vista.- -- This means that we can't bind directly to it since it may be missing.- -- Instead try to find it's address at runtime and if we don't succeed consider the- -- function failed.- addr_m <- (fmap Just $ failIfNull "getProcAddress" $ getProcAddress dllHwnd "GetFinalPathNameByHandleW")- `catch` (\(_ :: SomeException) -> return Nothing)- case addr_m of- Nothing -> return Nothing- Just addr -> do handle <- failIf (==iNVALID_HANDLE_VALUE) "CreateFile"- $ createFile name- gENERIC_READ- fILE_SHARE_READ- Nothing- oPEN_EXISTING- (fILE_ATTRIBUTE_NORMAL .|. fILE_FLAG_BACKUP_SEMANTICS)- Nothing- let fnPtr = makeGetFinalPathNameByHandle $ castPtrToFunPtr addr- -- First try to resolve the path to get the actual path- -- of any symlinks or other file system redirections that- -- may be in place. However this function can fail, and in- -- the event it does fail, we need to try using the- -- original path and see if we can decompose that.- -- If the call fails Win32.try will raise an exception- -- that needs to be caught. See #14159- path <- (Win32.try "GetFinalPathName"- (\buf len -> fnPtr handle buf len 0) 512- `finally` closeHandle handle)- `catch`- (\(_ :: IOException) -> return name)- return $ Just path--type GetFinalPath = HANDLE -> LPTSTR -> DWORD -> DWORD -> IO DWORD--foreign import WINDOWS_CCONV unsafe "dynamic"- makeGetFinalPathNameByHandle :: FunPtr GetFinalPath -> GetFinalPath-#else-getBaseDir = return Nothing-#endif--#ifdef mingw32_HOST_OS-foreign import ccall unsafe "_getpid" getProcessID :: IO Int -- relies on Int == Int32 on Windows-#else-getProcessID :: IO Int-getProcessID = System.Posix.Internals.c_getpid >>= return . fromIntegral-#endif---- Divvy up text stream into lines, taking platform dependent--- line termination into account.-linesPlatform :: String -> [String]-#if !defined(mingw32_HOST_OS)-linesPlatform ls = lines ls-#else-linesPlatform "" = []-linesPlatform xs =- case lineBreak xs of- (as,xs1) -> as : linesPlatform xs1- where- lineBreak "" = ("","")- lineBreak ('\r':'\n':xs) = ([],xs)- lineBreak ('\n':xs) = ([],xs)- lineBreak (x:xs) = let (as,bs) = lineBreak xs in (x:as,bs)--#endif--linkDynLib :: DynFlags -> [String] -> [InstalledUnitId] -> IO ()-linkDynLib dflags0 o_files dep_packages- = do- let -- This is a rather ugly hack to fix dynamically linked- -- GHC on Windows. If GHC is linked with -threaded, then- -- it links against libHSrts_thr. But if base is linked- -- against libHSrts, then both end up getting loaded,- -- and things go wrong. We therefore link the libraries- -- with the same RTS flags that we link GHC with.- dflags1 = if cGhcThreaded then addWay' WayThreaded dflags0- else dflags0- dflags2 = if cGhcDebugged then addWay' WayDebug dflags1- else dflags1- dflags = updateWays dflags2-- verbFlags = getVerbFlags dflags- o_file = outputFile dflags-- pkgs <- getPreloadPackagesAnd dflags dep_packages-- let pkg_lib_paths = collectLibraryPaths dflags pkgs- let pkg_lib_path_opts = concatMap get_pkg_lib_path_opts pkg_lib_paths- get_pkg_lib_path_opts l- | ( osElfTarget (platformOS (targetPlatform dflags)) ||- osMachOTarget (platformOS (targetPlatform dflags)) ) &&- dynLibLoader dflags == SystemDependent &&- WayDyn `elem` ways dflags- = ["-L" ++ l, "-Xlinker", "-rpath", "-Xlinker", l]- -- See Note [-Xlinker -rpath vs -Wl,-rpath]- | otherwise = ["-L" ++ l]-- let lib_paths = libraryPaths dflags- let lib_path_opts = map ("-L"++) lib_paths-- -- We don't want to link our dynamic libs against the RTS package,- -- because the RTS lib comes in several flavours and we want to be- -- able to pick the flavour when a binary is linked.- -- On Windows we need to link the RTS import lib as Windows does- -- not allow undefined symbols.- -- The RTS library path is still added to the library search path- -- above in case the RTS is being explicitly linked in (see #3807).- let platform = targetPlatform dflags- os = platformOS platform- pkgs_no_rts = case os of- OSMinGW32 ->- pkgs- _ ->- filter ((/= rtsUnitId) . packageConfigId) pkgs- let pkg_link_opts = let (package_hs_libs, extra_libs, other_flags) = collectLinkOpts dflags pkgs_no_rts- in package_hs_libs ++ extra_libs ++ other_flags-- -- probably _stub.o files- -- and last temporary shared object file- let extra_ld_inputs = ldInputs dflags-- -- frameworks- pkg_framework_opts <- getPkgFrameworkOpts dflags platform- (map unitId pkgs)- let framework_opts = getFrameworkOpts dflags platform-- case os of- OSMinGW32 -> do- -------------------------------------------------------------- -- Making a DLL- -------------------------------------------------------------- let output_fn = case o_file of- Just s -> s- Nothing -> "HSdll.dll"-- runLink dflags (- map Option verbFlags- ++ [ Option "-o"- , FileOption "" output_fn- , Option "-shared"- ] ++- [ FileOption "-Wl,--out-implib=" (output_fn ++ ".a")- | gopt Opt_SharedImplib dflags- ]- ++ map (FileOption "") o_files-- -- Permit the linker to auto link _symbol to _imp_symbol- -- This lets us link against DLLs without needing an "import library"- ++ [Option "-Wl,--enable-auto-import"]-- ++ extra_ld_inputs- ++ map Option (- lib_path_opts- ++ pkg_lib_path_opts- ++ pkg_link_opts- ))- OSDarwin -> do- -------------------------------------------------------------------- -- Making a darwin dylib- -------------------------------------------------------------------- -- About the options used for Darwin:- -- -dynamiclib- -- Apple's way of saying -shared- -- -undefined dynamic_lookup:- -- Without these options, we'd have to specify the correct- -- dependencies for each of the dylibs. Note that we could- -- (and should) do without this for all libraries except- -- the RTS; all we need to do is to pass the correct- -- HSfoo_dyn.dylib files to the link command.- -- This feature requires Mac OS X 10.3 or later; there is- -- a similar feature, -flat_namespace -undefined suppress,- -- which works on earlier versions, but it has other- -- disadvantages.- -- -single_module- -- Build the dynamic library as a single "module", i.e. no- -- dynamic binding nonsense when referring to symbols from- -- within the library. The NCG assumes that this option is- -- specified (on i386, at least).- -- -install_name- -- Mac OS/X stores the path where a dynamic library is (to- -- be) installed in the library itself. It's called the- -- "install name" of the library. Then any library or- -- executable that links against it before it's installed- -- will search for it in its ultimate install location.- -- By default we set the install name to the absolute path- -- at build time, but it can be overridden by the- -- -dylib-install-name option passed to ghc. Cabal does- -- this.- --------------------------------------------------------------------- let output_fn = case o_file of { Just s -> s; Nothing -> "a.out"; }-- instName <- case dylibInstallName dflags of- Just n -> return n- Nothing -> return $ "@rpath" `combine` (takeFileName output_fn)- runLink dflags (- map Option verbFlags- ++ [ Option "-dynamiclib"- , Option "-o"- , FileOption "" output_fn- ]- ++ map Option o_files- ++ [ Option "-undefined",- Option "dynamic_lookup",- Option "-single_module" ]- ++ (if platformArch platform == ArchX86_64- then [ ]- else [ Option "-Wl,-read_only_relocs,suppress" ])- ++ [ Option "-install_name", Option instName ]- ++ map Option lib_path_opts- ++ extra_ld_inputs- ++ map Option framework_opts- ++ map Option pkg_lib_path_opts- ++ map Option pkg_link_opts- ++ map Option pkg_framework_opts- )- OSiOS -> throwGhcExceptionIO (ProgramError "dynamic libraries are not supported on iOS target")+ -- * Initialisation+ initSysTools,+ initLlvmTargets,++ -- * Interface to system tools+ module SysTools.Tasks,+ module SysTools.Info,++ linkDynLib,++ copy,+ copyWithHeader,++ -- * General utilities+ Option(..),+ expandTopDir,++ -- * Platform-specifics+ libmLinkOpts,++ -- * Mac OS X frameworks+ getPkgFrameworkOpts,+ getFrameworkOpts+ ) where++#include "HsVersions.h"++import GhcPrelude++import Module+import Packages+import Config+import Outputable+import ErrUtils+import Platform+import Util+import DynFlags++import System.FilePath+import System.IO+import System.Directory+import SysTools.ExtraObj+import SysTools.Info+import SysTools.Tasks+import SysTools.BaseDir++{-+Note [How GHC finds toolchain utilities]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++SysTools.initSysProgs figures out exactly where all the auxiliary programs+are, and initialises mutable variables to make it easy to call them.+To to this, it makes use of definitions in Config.hs, which is a Haskell+file containing variables whose value is figured out by the build system.++Config.hs contains two sorts of things++ cGCC, The *names* of the programs+ cCPP e.g. cGCC = gcc+ cUNLIT cCPP = gcc -E+ etc They do *not* include paths+++ cUNLIT_DIR The *path* to the directory containing unlit, split etc+ cSPLIT_DIR *relative* to the root of the build tree,+ for use when running *in-place* in a build tree (only)+++---------------------------------------------+NOTES for an ALTERNATIVE scheme (i.e *not* what is currently implemented):++Another hair-brained scheme for simplifying the current tool location+nightmare in GHC: Simon originally suggested using another+configuration file along the lines of GCC's specs file - which is fine+except that it means adding code to read yet another configuration+file. What I didn't notice is that the current package.conf is+general enough to do this:++Package+ {name = "tools", import_dirs = [], source_dirs = [],+ library_dirs = [], hs_libraries = [], extra_libraries = [],+ include_dirs = [], c_includes = [], package_deps = [],+ extra_ghc_opts = ["-pgmc/usr/bin/gcc","-pgml${topdir}/bin/unlit", ... etc.],+ extra_cc_opts = [], extra_ld_opts = []}++Which would have the advantage that we get to collect together in one+place the path-specific package stuff with the path-specific tool+stuff.+ End of NOTES+---------------------------------------------++************************************************************************+* *+\subsection{Initialisation}+* *+************************************************************************+-}++initLlvmTargets :: Maybe String+ -> IO LlvmTargets+initLlvmTargets mbMinusB+ = do top_dir <- findTopDir mbMinusB+ let llvmTargetsFile = top_dir </> "llvm-targets"+ llvmTargetsStr <- readFile llvmTargetsFile+ case maybeReadFuzzy llvmTargetsStr of+ Just s -> return (fmap mkLlvmTarget <$> s)+ Nothing -> pgmError ("Can't parse " ++ show llvmTargetsFile)+ where+ mkLlvmTarget :: (String, String, String) -> LlvmTarget+ mkLlvmTarget (dl, cpu, attrs) = LlvmTarget dl cpu (words attrs)+++initSysTools :: Maybe String -- Maybe TopDir path (without the '-B' prefix)+ -> IO Settings -- Set all the mutable variables above, holding+ -- (a) the system programs+ -- (b) the package-config file+ -- (c) the GHC usage message+initSysTools mbMinusB+ = do top_dir <- findTopDir mbMinusB+ -- see Note [topdir: How GHC finds its files]+ -- NB: top_dir is assumed to be in standard Unix+ -- format, '/' separated++ let settingsFile = top_dir </> "settings"+ platformConstantsFile = top_dir </> "platformConstants"+ installed :: FilePath -> FilePath+ installed file = top_dir </> file+ libexec :: FilePath -> FilePath+ libexec file = top_dir </> "bin" </> file++ settingsStr <- readFile settingsFile+ platformConstantsStr <- readFile platformConstantsFile+ mySettings <- case maybeReadFuzzy settingsStr of+ Just s ->+ return s+ Nothing ->+ pgmError ("Can't parse " ++ show settingsFile)+ platformConstants <- case maybeReadFuzzy platformConstantsStr of+ Just s ->+ return s+ Nothing ->+ pgmError ("Can't parse " +++ show platformConstantsFile)+ let getSetting key = case lookup key mySettings of+ Just xs -> return $ expandTopDir top_dir xs+ Nothing -> pgmError ("No entry for " ++ show key ++ " in " ++ show settingsFile)+ getBooleanSetting key = case lookup key mySettings of+ Just "YES" -> return True+ Just "NO" -> return False+ Just xs -> pgmError ("Bad value for " ++ show key ++ ": " ++ show xs)+ Nothing -> pgmError ("No entry for " ++ show key ++ " in " ++ show settingsFile)+ readSetting key = case lookup key mySettings of+ Just xs ->+ case maybeRead xs of+ Just v -> return v+ Nothing -> pgmError ("Failed to read " ++ show key ++ " value " ++ show xs)+ Nothing -> pgmError ("No entry for " ++ show key ++ " in " ++ show settingsFile)+ crossCompiling <- getBooleanSetting "cross compiling"+ targetArch <- readSetting "target arch"+ targetOS <- readSetting "target os"+ targetWordSize <- readSetting "target word size"+ targetUnregisterised <- getBooleanSetting "Unregisterised"+ targetHasGnuNonexecStack <- readSetting "target has GNU nonexec stack"+ targetHasIdentDirective <- readSetting "target has .ident directive"+ targetHasSubsectionsViaSymbols <- readSetting "target has subsections via symbols"+ myExtraGccViaCFlags <- getSetting "GCC extra via C opts"+ -- On Windows, mingw is distributed with GHC,+ -- so we look in TopDir/../mingw/bin+ -- It would perhaps be nice to be able to override this+ -- with the settings file, but it would be a little fiddly+ -- to make that possible, so for now you can't.+ gcc_prog <- getSetting "C compiler command"+ gcc_args_str <- getSetting "C compiler flags"+ gccSupportsNoPie <- getBooleanSetting "C compiler supports -no-pie"+ cpp_prog <- getSetting "Haskell CPP command"+ cpp_args_str <- getSetting "Haskell CPP flags"+ let unreg_gcc_args = if targetUnregisterised+ then ["-DNO_REGS", "-DUSE_MINIINTERPRETER"]+ else []+ -- TABLES_NEXT_TO_CODE affects the info table layout.+ tntc_gcc_args+ | mkTablesNextToCode targetUnregisterised+ = ["-DTABLES_NEXT_TO_CODE"]+ | otherwise = []+ cpp_args= map Option (words cpp_args_str)+ gcc_args = map Option (words gcc_args_str+ ++ unreg_gcc_args+ ++ tntc_gcc_args)+ ldSupportsCompactUnwind <- getBooleanSetting "ld supports compact unwind"+ ldSupportsBuildId <- getBooleanSetting "ld supports build-id"+ ldSupportsFilelist <- getBooleanSetting "ld supports filelist"+ ldIsGnuLd <- getBooleanSetting "ld is GNU ld"+ perl_path <- getSetting "perl command"++ let pkgconfig_path = installed "package.conf.d"+ ghc_usage_msg_path = installed "ghc-usage.txt"+ ghci_usage_msg_path = installed "ghci-usage.txt"++ -- For all systems, unlit, split, mangle are GHC utilities+ -- architecture-specific stuff is done when building Config.hs+ unlit_path = libexec cGHC_UNLIT_PGM++ -- split is a Perl script+ split_script = libexec cGHC_SPLIT_PGM++ windres_path <- getSetting "windres command"+ libtool_path <- getSetting "libtool command"+ ar_path <- getSetting "ar command"+ ranlib_path <- getSetting "ranlib command"++ tmpdir <- getTemporaryDirectory++ touch_path <- getSetting "touch command"++ let -- On Win32 we don't want to rely on #!/bin/perl, so we prepend+ -- a call to Perl to get the invocation of split.+ -- On Unix, scripts are invoked using the '#!' method. Binary+ -- installations of GHC on Unix place the correct line on the+ -- front of the script at installation time, so we don't want+ -- to wire-in our knowledge of $(PERL) on the host system here.+ (split_prog, split_args)+ | isWindowsHost = (perl_path, [Option split_script])+ | otherwise = (split_script, [])+ mkdll_prog <- getSetting "dllwrap command"+ let mkdll_args = []++ -- cpp is derived from gcc on all platforms+ -- HACK, see setPgmP below. We keep 'words' here to remember to fix+ -- Config.hs one day.+++ -- Other things being equal, as and ld are simply gcc+ gcc_link_args_str <- getSetting "C compiler link flags"+ let as_prog = gcc_prog+ as_args = gcc_args+ ld_prog = gcc_prog+ ld_args = gcc_args ++ map Option (words gcc_link_args_str)++ -- We just assume on command line+ lc_prog <- getSetting "LLVM llc command"+ lo_prog <- getSetting "LLVM opt command"+ lcc_prog <- getSetting "LLVM clang command"++ let iserv_prog = libexec "ghc-iserv"++ let platform = Platform {+ platformArch = targetArch,+ platformOS = targetOS,+ platformWordSize = targetWordSize,+ platformUnregisterised = targetUnregisterised,+ platformHasGnuNonexecStack = targetHasGnuNonexecStack,+ platformHasIdentDirective = targetHasIdentDirective,+ platformHasSubsectionsViaSymbols = targetHasSubsectionsViaSymbols,+ platformIsCrossCompiling = crossCompiling+ }++ return $ Settings {+ sTargetPlatform = platform,+ sTmpDir = normalise tmpdir,+ sGhcUsagePath = ghc_usage_msg_path,+ sGhciUsagePath = ghci_usage_msg_path,+ sTopDir = top_dir,+ sRawSettings = mySettings,+ sExtraGccViaCFlags = words myExtraGccViaCFlags,+ sSystemPackageConfig = pkgconfig_path,+ sLdSupportsCompactUnwind = ldSupportsCompactUnwind,+ sLdSupportsBuildId = ldSupportsBuildId,+ sLdSupportsFilelist = ldSupportsFilelist,+ sLdIsGnuLd = ldIsGnuLd,+ sGccSupportsNoPie = gccSupportsNoPie,+ sProgramName = "ghc",+ sProjectVersion = cProjectVersion,+ sPgm_L = unlit_path,+ sPgm_P = (cpp_prog, cpp_args),+ sPgm_F = "",+ sPgm_c = (gcc_prog, gcc_args),+ sPgm_s = (split_prog,split_args),+ sPgm_a = (as_prog, as_args),+ sPgm_l = (ld_prog, ld_args),+ sPgm_dll = (mkdll_prog,mkdll_args),+ sPgm_T = touch_path,+ sPgm_windres = windres_path,+ sPgm_libtool = libtool_path,+ sPgm_ar = ar_path,+ sPgm_ranlib = ranlib_path,+ sPgm_lo = (lo_prog,[]),+ sPgm_lc = (lc_prog,[]),+ sPgm_lcc = (lcc_prog,[]),+ sPgm_i = iserv_prog,+ sOpt_L = [],+ sOpt_P = [],+ sOpt_F = [],+ sOpt_c = [],+ sOpt_a = [],+ sOpt_l = [],+ sOpt_windres = [],+ sOpt_lcc = [],+ sOpt_lo = [],+ sOpt_lc = [],+ sOpt_i = [],+ sPlatformConstants = platformConstants+ }+++{- Note [Windows stack usage]++See: Trac #8870 (and #8834 for related info) and #12186++On Windows, occasionally we need to grow the stack. In order to do+this, we would normally just bump the stack pointer - but there's a+catch on Windows.++If the stack pointer is bumped by more than a single page, then the+pages between the initial pointer and the resulting location must be+properly committed by the Windows virtual memory subsystem. This is+only needed in the event we bump by more than one page (i.e 4097 bytes+or more).++Windows compilers solve this by emitting a call to a special function+called _chkstk, which does this committing of the pages for you.++The reason this was causing a segfault was because due to the fact the+new code generator tends to generate larger functions, we needed more+stack space in GHC itself. In the x86 codegen, we needed approximately+~12kb of stack space in one go, which caused the process to segfault,+as the intervening pages were not committed.++GCC can emit such a check for us automatically but only when the flag+-fstack-check is used.++See https://gcc.gnu.org/onlinedocs/gnat_ugn/Stack-Overflow-Checking.html+for more information.++-}++copy :: DynFlags -> String -> FilePath -> FilePath -> IO ()+copy dflags purpose from to = copyWithHeader dflags purpose Nothing from to++copyWithHeader :: DynFlags -> String -> Maybe String -> FilePath -> FilePath+ -> IO ()+copyWithHeader dflags purpose maybe_header from to = do+ showPass dflags purpose++ hout <- openBinaryFile to WriteMode+ hin <- openBinaryFile from ReadMode+ ls <- hGetContents hin -- inefficient, but it'll do for now. ToDo: speed up+ maybe (return ()) (header hout) maybe_header+ hPutStr hout ls+ hClose hout+ hClose hin+ where+ -- write the header string in UTF-8. The header is something like+ -- {-# LINE "foo.hs" #-}+ -- and we want to make sure a Unicode filename isn't mangled.+ header h str = do+ hSetEncoding h utf8+ hPutStr h str+ hSetBinaryMode h True++{-+************************************************************************+* *+\subsection{Support code}+* *+************************************************************************+-}++linkDynLib :: DynFlags -> [String] -> [InstalledUnitId] -> IO ()+linkDynLib dflags0 o_files dep_packages+ = do+ let -- This is a rather ugly hack to fix dynamically linked+ -- GHC on Windows. If GHC is linked with -threaded, then+ -- it links against libHSrts_thr. But if base is linked+ -- against libHSrts, then both end up getting loaded,+ -- and things go wrong. We therefore link the libraries+ -- with the same RTS flags that we link GHC with.+ dflags1 = if cGhcThreaded then addWay' WayThreaded dflags0+ else dflags0+ dflags2 = if cGhcDebugged then addWay' WayDebug dflags1+ else dflags1+ dflags = updateWays dflags2++ verbFlags = getVerbFlags dflags+ o_file = outputFile dflags++ pkgs <- getPreloadPackagesAnd dflags dep_packages++ let pkg_lib_paths = collectLibraryPaths dflags pkgs+ let pkg_lib_path_opts = concatMap get_pkg_lib_path_opts pkg_lib_paths+ get_pkg_lib_path_opts l+ | ( osElfTarget (platformOS (targetPlatform dflags)) ||+ osMachOTarget (platformOS (targetPlatform dflags)) ) &&+ dynLibLoader dflags == SystemDependent &&+ WayDyn `elem` ways dflags+ = ["-L" ++ l, "-Xlinker", "-rpath", "-Xlinker", l]+ -- See Note [-Xlinker -rpath vs -Wl,-rpath]+ | otherwise = ["-L" ++ l]++ let lib_paths = libraryPaths dflags+ let lib_path_opts = map ("-L"++) lib_paths++ -- We don't want to link our dynamic libs against the RTS package,+ -- because the RTS lib comes in several flavours and we want to be+ -- able to pick the flavour when a binary is linked.+ -- On Windows we need to link the RTS import lib as Windows does+ -- not allow undefined symbols.+ -- The RTS library path is still added to the library search path+ -- above in case the RTS is being explicitly linked in (see #3807).+ let platform = targetPlatform dflags+ os = platformOS platform+ pkgs_no_rts = case os of+ OSMinGW32 ->+ pkgs+ _ ->+ filter ((/= rtsUnitId) . packageConfigId) pkgs+ let pkg_link_opts = let (package_hs_libs, extra_libs, other_flags) = collectLinkOpts dflags pkgs_no_rts+ in package_hs_libs ++ extra_libs ++ other_flags++ -- probably _stub.o files+ -- and last temporary shared object file+ let extra_ld_inputs = ldInputs dflags++ -- frameworks+ pkg_framework_opts <- getPkgFrameworkOpts dflags platform+ (map unitId pkgs)+ let framework_opts = getFrameworkOpts dflags platform++ case os of+ OSMinGW32 -> do+ -------------------------------------------------------------+ -- Making a DLL+ -------------------------------------------------------------+ let output_fn = case o_file of+ Just s -> s+ Nothing -> "HSdll.dll"++ runLink dflags (+ map Option verbFlags+ ++ [ Option "-o"+ , FileOption "" output_fn+ , Option "-shared"+ ] +++ [ FileOption "-Wl,--out-implib=" (output_fn ++ ".a")+ | gopt Opt_SharedImplib dflags+ ]+ ++ map (FileOption "") o_files++ -- Permit the linker to auto link _symbol to _imp_symbol+ -- This lets us link against DLLs without needing an "import library"+ ++ [Option "-Wl,--enable-auto-import"]++ ++ extra_ld_inputs+ ++ map Option (+ lib_path_opts+ ++ pkg_lib_path_opts+ ++ pkg_link_opts+ ))+ _ | os == OSDarwin -> do+ -------------------------------------------------------------------+ -- Making a darwin dylib+ -------------------------------------------------------------------+ -- About the options used for Darwin:+ -- -dynamiclib+ -- Apple's way of saying -shared+ -- -undefined dynamic_lookup:+ -- Without these options, we'd have to specify the correct+ -- dependencies for each of the dylibs. Note that we could+ -- (and should) do without this for all libraries except+ -- the RTS; all we need to do is to pass the correct+ -- HSfoo_dyn.dylib files to the link command.+ -- This feature requires Mac OS X 10.3 or later; there is+ -- a similar feature, -flat_namespace -undefined suppress,+ -- which works on earlier versions, but it has other+ -- disadvantages.+ -- -single_module+ -- Build the dynamic library as a single "module", i.e. no+ -- dynamic binding nonsense when referring to symbols from+ -- within the library. The NCG assumes that this option is+ -- specified (on i386, at least).+ -- -install_name+ -- Mac OS/X stores the path where a dynamic library is (to+ -- be) installed in the library itself. It's called the+ -- "install name" of the library. Then any library or+ -- executable that links against it before it's installed+ -- will search for it in its ultimate install location.+ -- By default we set the install name to the absolute path+ -- at build time, but it can be overridden by the+ -- -dylib-install-name option passed to ghc. Cabal does+ -- this.+ -------------------------------------------------------------------++ let output_fn = case o_file of { Just s -> s; Nothing -> "a.out"; }++ instName <- case dylibInstallName dflags of+ Just n -> return n+ Nothing -> return $ "@rpath" `combine` (takeFileName output_fn)+ runLink dflags (+ map Option verbFlags+ ++ [ Option "-dynamiclib"+ , Option "-o"+ , FileOption "" output_fn+ ]+ ++ map Option o_files+ ++ [ Option "-undefined",+ Option "dynamic_lookup",+ Option "-single_module" ]+ ++ (if platformArch platform == ArchX86_64+ then [ ]+ else [ Option "-Wl,-read_only_relocs,suppress" ])+ ++ [ Option "-install_name", Option instName ]+ ++ map Option lib_path_opts+ ++ extra_ld_inputs+ ++ map Option framework_opts+ ++ map Option pkg_lib_path_opts+ ++ map Option pkg_link_opts+ ++ map Option pkg_framework_opts+ ) _ -> do ------------------------------------------------------------------- -- Making a DSO
+ main/SysTools/BaseDir.hs view
@@ -0,0 +1,199 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ScopedTypeVariables #-}++{-+-----------------------------------------------------------------------------+--+-- (c) The University of Glasgow 2001-2017+--+-- Finding the compiler's base directory.+--+-----------------------------------------------------------------------------+-}++module SysTools.BaseDir (expandTopDir, findTopDir) where++#include "HsVersions.h"++import GhcPrelude++import Panic++import System.FilePath+import Data.List++-- POSIX+#if defined(darwin_HOST_OS) || defined(linux_HOST_OS)+import System.Environment (getExecutablePath)+#endif++-- Windows+#if defined(mingw32_HOST_OS)+#if MIN_VERSION_Win32(2,5,0)+import qualified System.Win32.Types as Win32+#else+import qualified System.Win32.Info as Win32+#endif+import Exception+import Foreign+import Foreign.C.String+import System.Directory+import System.Win32.Types (DWORD, LPTSTR, HANDLE)+import System.Win32.Types (failIfNull, failIf, iNVALID_HANDLE_VALUE)+import System.Win32.File (createFile,closeHandle, gENERIC_READ, fILE_SHARE_READ, oPEN_EXISTING, fILE_ATTRIBUTE_NORMAL, fILE_FLAG_BACKUP_SEMANTICS )+import System.Win32.DLL (loadLibrary, getProcAddress)+#endif++#if defined(mingw32_HOST_OS)+# if defined(i386_HOST_ARCH)+# define WINDOWS_CCONV stdcall+# elif defined(x86_64_HOST_ARCH)+# define WINDOWS_CCONV ccall+# else+# error Unknown mingw32 arch+# endif+#endif++{-+Note [topdir: How GHC finds its files]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++GHC needs various support files (library packages, RTS etc), plus+various auxiliary programs (cp, gcc, etc). It starts by finding topdir,+the root of GHC's support files++On Unix:+ - ghc always has a shell wrapper that passes a -B<dir> option++On Windows:+ - ghc never has a shell wrapper.+ - we can find the location of the ghc binary, which is+ $topdir/<foo>/<something>.exe+ where <something> may be "ghc", "ghc-stage2", or similar+ - we strip off the "<foo>/<something>.exe" to leave $topdir.++from topdir we can find package.conf, ghc-asm, etc.++-}++-- | Expand occurrences of the @$topdir@ interpolation in a string.+expandTopDir :: FilePath -> String -> String+expandTopDir top_dir str+ | Just str' <- stripPrefix "$topdir" str+ , null str' || isPathSeparator (head str')+ = top_dir ++ expandTopDir top_dir str'+expandTopDir top_dir (x:xs) = x : expandTopDir top_dir xs+expandTopDir _ [] = []++-- | Returns a Unix-format path pointing to TopDir.+findTopDir :: Maybe String -- Maybe TopDir path (without the '-B' prefix).+ -> IO String -- TopDir (in Unix format '/' separated)+findTopDir (Just minusb) = return (normalise minusb)+findTopDir Nothing+ = do -- Get directory of executable+ maybe_exec_dir <- getBaseDir+ case maybe_exec_dir of+ -- "Just" on Windows, "Nothing" on unix+ Nothing -> throwGhcExceptionIO (InstallationError "missing -B<dir> option")+ Just dir -> return dir++getBaseDir :: IO (Maybe String)+#if defined(mingw32_HOST_OS)+-- Assuming we are running ghc, accessed by path $(stuff)/<foo>/ghc.exe,+-- return the path $(stuff)/lib.+getBaseDir = try_size 2048 -- plenty, PATH_MAX is 512 under Win32.+ where+ try_size size = allocaArray (fromIntegral size) $ \buf -> do+ ret <- c_GetModuleFileName nullPtr buf size+ case ret of+ 0 -> return Nothing+ _ | ret < size -> do+ path <- peekCWString buf+ real <- getFinalPath path -- try to resolve symlinks paths+ let libdir = (buildLibDir . sanitize . maybe path id) real+ exists <- doesDirectoryExist libdir+ if exists+ then return $ Just libdir+ else fail path+ | otherwise -> try_size (size * 2)++ -- getFinalPath returns paths in full raw form.+ -- Unfortunately GHC isn't set up to handle these+ -- So if the call succeeded, we need to drop the+ -- \\?\ prefix.+ sanitize s = if "\\\\?\\" `isPrefixOf` s+ then drop 4 s+ else s++ buildLibDir :: FilePath -> FilePath+ buildLibDir s =+ (takeDirectory . takeDirectory . normalise $ s) </> "lib"++ fail s = panic ("can't decompose ghc.exe path: " ++ show s)++foreign import WINDOWS_CCONV unsafe "windows.h GetModuleFileNameW"+ c_GetModuleFileName :: Ptr () -> CWString -> Word32 -> IO Word32++-- Attempt to resolve symlinks in order to find the actual location GHC+-- is located at. See Trac #11759.+getFinalPath :: FilePath -> IO (Maybe FilePath)+getFinalPath name = do+ dllHwnd <- failIfNull "LoadLibrary" $ loadLibrary "kernel32.dll"+ -- Note: The API GetFinalPathNameByHandleW is only available starting from Windows Vista.+ -- This means that we can't bind directly to it since it may be missing.+ -- Instead try to find it's address at runtime and if we don't succeed consider the+ -- function failed.+ addr_m <- (fmap Just $ failIfNull "getProcAddress" $ getProcAddress dllHwnd "GetFinalPathNameByHandleW")+ `catch` (\(_ :: SomeException) -> return Nothing)+ case addr_m of+ Nothing -> return Nothing+ Just addr -> do handle <- failIf (==iNVALID_HANDLE_VALUE) "CreateFile"+ $ createFile name+ gENERIC_READ+ fILE_SHARE_READ+ Nothing+ oPEN_EXISTING+ (fILE_ATTRIBUTE_NORMAL .|. fILE_FLAG_BACKUP_SEMANTICS)+ Nothing+ let fnPtr = makeGetFinalPathNameByHandle $ castPtrToFunPtr addr+ -- First try to resolve the path to get the actual path+ -- of any symlinks or other file system redirections that+ -- may be in place. However this function can fail, and in+ -- the event it does fail, we need to try using the+ -- original path and see if we can decompose that.+ -- If the call fails Win32.try will raise an exception+ -- that needs to be caught. See #14159+ path <- (Win32.try "GetFinalPathName"+ (\buf len -> fnPtr handle buf len 0) 512+ `finally` closeHandle handle)+ `catch`+ (\(_ :: IOException) -> return name)+ return $ Just path++type GetFinalPath = HANDLE -> LPTSTR -> DWORD -> DWORD -> IO DWORD++foreign import WINDOWS_CCONV unsafe "dynamic"+ makeGetFinalPathNameByHandle :: FunPtr GetFinalPath -> GetFinalPath+#elif defined(darwin_HOST_OS) || defined(linux_HOST_OS)+-- on unix, this is a bit more confusing.+-- The layout right now is somehting like+--+-- /bin/ghc-X.Y.Z <- wrapper script (1)+-- /bin/ghc <- symlink to wrapper script (2)+-- /lib/ghc-X.Y.Z/bin/ghc <- ghc executable (3)+-- /lib/ghc-X.Y.Z <- $topdir (4)+--+-- As such, we first need to find the absolute location to the+-- binary.+--+-- getExecutablePath will return (3). One takeDirectory will+-- give use /lib/ghc-X.Y.Z/bin, and another will give us (4).+--+-- This of course only works due to the current layout. If+-- the layout is changed, such that we have ghc-X.Y.Z/{bin,lib}+-- this would need to be changed accordingly.+--+getBaseDir = Just . (\p -> p </> "lib") . takeDirectory . takeDirectory <$> getExecutablePath+#else+getBaseDir = return Nothing+#endif
+ main/SysTools/ExtraObj.hs view
@@ -0,0 +1,239 @@+-----------------------------------------------------------------------------+--+-- GHC Extra object linking code+--+-- (c) The GHC Team 2017+--+-----------------------------------------------------------------------------++module SysTools.ExtraObj (+ mkExtraObj, mkExtraObjToLinkIntoBinary, mkNoteObjsToLinkIntoBinary,+ checkLinkInfo, getLinkInfo, getCompilerInfo,+ ghcLinkInfoSectionName, ghcLinkInfoNoteName, platformSupportsSavingLinkOpts,+ haveRtsOptsFlags+) where++import AsmUtils+import ErrUtils+import DynFlags+import Packages+import Platform+import Outputable+import SrcLoc ( noSrcSpan )+import Module+import Elf+import Util+import GhcPrelude++import Control.Monad+import Data.Maybe++import Control.Monad.IO.Class++import FileCleanup+import SysTools.Tasks+import SysTools.Info++mkExtraObj :: DynFlags -> Suffix -> String -> IO FilePath+mkExtraObj dflags extn xs+ = do cFile <- newTempName dflags TFL_CurrentModule extn+ oFile <- newTempName dflags TFL_GhcSession "o"+ writeFile cFile xs+ ccInfo <- liftIO $ getCompilerInfo dflags+ runCc dflags+ ([Option "-c",+ FileOption "" cFile,+ Option "-o",+ FileOption "" oFile]+ ++ if extn /= "s"+ then cOpts+ else asmOpts ccInfo)+ return oFile+ where+ -- Pass a different set of options to the C compiler depending one whether+ -- we're compiling C or assembler. When compiling C, we pass the usual+ -- set of include directories and PIC flags.+ cOpts = map Option (picCCOpts dflags)+ ++ map (FileOption "-I")+ (includeDirs $ getPackageDetails dflags rtsUnitId)++ -- When compiling assembler code, we drop the usual C options, and if the+ -- compiler is Clang, we add an extra argument to tell Clang to ignore+ -- unused command line options. See trac #11684.+ asmOpts ccInfo =+ if any (ccInfo ==) [Clang, AppleClang, AppleClang51]+ then [Option "-Qunused-arguments"]+ else []++-- When linking a binary, we need to create a C main() function that+-- starts everything off. This used to be compiled statically as part+-- of the RTS, but that made it hard to change the -rtsopts setting,+-- so now we generate and compile a main() stub as part of every+-- binary and pass the -rtsopts setting directly to the RTS (#5373)+--+-- On Windows, when making a shared library we also may need a DllMain.+--+mkExtraObjToLinkIntoBinary :: DynFlags -> IO FilePath+mkExtraObjToLinkIntoBinary dflags = do+ when (gopt Opt_NoHsMain dflags && haveRtsOptsFlags dflags) $ do+ putLogMsg dflags NoReason SevInfo noSrcSpan+ (defaultUserStyle dflags)+ (text "Warning: -rtsopts and -with-rtsopts have no effect with -no-hs-main." $$+ text " Call hs_init_ghc() from your main() function to set these options.")++ mkExtraObj dflags "c" (showSDoc dflags main)+ where+ main+ | gopt Opt_NoHsMain dflags = Outputable.empty+ | otherwise+ = case ghcLink dflags of+ LinkDynLib -> if platformOS (targetPlatform dflags) == OSMinGW32+ then dllMain+ else Outputable.empty+ _ -> exeMain++ exeMain = vcat [+ text "#include \"Rts.h\"",+ text "extern StgClosure ZCMain_main_closure;",+ text "int main(int argc, char *argv[])",+ char '{',+ text " RtsConfig __conf = defaultRtsConfig;",+ text " __conf.rts_opts_enabled = "+ <> text (show (rtsOptsEnabled dflags)) <> semi,+ text " __conf.rts_opts_suggestions = "+ <> text (if rtsOptsSuggestions dflags+ then "true"+ else "false") <> semi,+ case rtsOpts dflags of+ Nothing -> Outputable.empty+ Just opts -> text " __conf.rts_opts= " <>+ text (show opts) <> semi,+ text " __conf.rts_hs_main = true;",+ text " return hs_main(argc,argv,&ZCMain_main_closure,__conf);",+ char '}',+ char '\n' -- final newline, to keep gcc happy+ ]++ dllMain = vcat [+ text "#include \"Rts.h\"",+ text "#include <windows.h>",+ text "#include <stdbool.h>",+ char '\n',+ text "bool",+ text "WINAPI",+ text "DllMain ( HINSTANCE hInstance STG_UNUSED",+ text " , DWORD reason STG_UNUSED",+ text " , LPVOID reserved STG_UNUSED",+ text " )",+ text "{",+ text " return true;",+ text "}",+ char '\n' -- final newline, to keep gcc happy+ ]++-- Write out the link info section into a new assembly file. Previously+-- this was included as inline assembly in the main.c file but this+-- is pretty fragile. gas gets upset trying to calculate relative offsets+-- that span the .note section (notably .text) when debug info is present+mkNoteObjsToLinkIntoBinary :: DynFlags -> [InstalledUnitId] -> IO [FilePath]+mkNoteObjsToLinkIntoBinary dflags dep_packages = do+ link_info <- getLinkInfo dflags dep_packages++ if (platformSupportsSavingLinkOpts (platformOS (targetPlatform dflags)))+ then fmap (:[]) $ mkExtraObj dflags "s" (showSDoc dflags (link_opts link_info))+ else return []++ where+ link_opts info = hcat [+ -- "link info" section (see Note [LinkInfo section])+ makeElfNote ghcLinkInfoSectionName ghcLinkInfoNoteName 0 info,++ -- ALL generated assembly must have this section to disable+ -- executable stacks. See also+ -- compiler/nativeGen/AsmCodeGen.hs for another instance+ -- where we need to do this.+ if platformHasGnuNonexecStack (targetPlatform dflags)+ then text ".section .note.GNU-stack,\"\","+ <> sectionType "progbits" <> char '\n'+ else Outputable.empty+ ]++-- | Return the "link info" string+--+-- See Note [LinkInfo section]+getLinkInfo :: DynFlags -> [InstalledUnitId] -> IO String+getLinkInfo dflags dep_packages = do+ package_link_opts <- getPackageLinkOpts dflags dep_packages+ pkg_frameworks <- if platformUsesFrameworks (targetPlatform dflags)+ then getPackageFrameworks dflags dep_packages+ else return []+ let extra_ld_inputs = ldInputs dflags+ let+ link_info = (package_link_opts,+ pkg_frameworks,+ rtsOpts dflags,+ rtsOptsEnabled dflags,+ gopt Opt_NoHsMain dflags,+ map showOpt extra_ld_inputs,+ getOpts dflags opt_l)+ --+ return (show link_info)++platformSupportsSavingLinkOpts :: OS -> Bool+platformSupportsSavingLinkOpts os+ | os == OSSolaris2 = False -- see #5382+ | otherwise = osElfTarget os++-- See Note [LinkInfo section]+ghcLinkInfoSectionName :: String+ghcLinkInfoSectionName = ".debug-ghc-link-info"+ -- if we use the ".debug" prefix, then strip will strip it by default++-- Identifier for the note (see Note [LinkInfo section])+ghcLinkInfoNoteName :: String+ghcLinkInfoNoteName = "GHC link info"++-- Returns 'False' if it was, and we can avoid linking, because the+-- previous binary was linked with "the same options".+checkLinkInfo :: DynFlags -> [InstalledUnitId] -> FilePath -> IO Bool+checkLinkInfo dflags pkg_deps exe_file+ | not (platformSupportsSavingLinkOpts (platformOS (targetPlatform dflags)))+ -- ToDo: Windows and OS X do not use the ELF binary format, so+ -- readelf does not work there. We need to find another way to do+ -- this.+ = return False -- conservatively we should return True, but not+ -- linking in this case was the behaviour for a long+ -- time so we leave it as-is.+ | otherwise+ = do+ link_info <- getLinkInfo dflags pkg_deps+ debugTraceMsg dflags 3 $ text ("Link info: " ++ link_info)+ m_exe_link_info <- readElfNoteAsString dflags exe_file+ ghcLinkInfoSectionName ghcLinkInfoNoteName+ let sameLinkInfo = (Just link_info == m_exe_link_info)+ debugTraceMsg dflags 3 $ case m_exe_link_info of+ Nothing -> text "Exe link info: Not found"+ Just s+ | sameLinkInfo -> text ("Exe link info is the same")+ | otherwise -> text ("Exe link info is different: " ++ s)+ return (not sameLinkInfo)++{- Note [LinkInfo section]+ ~~~~~~~~~~~~~~~~~~~~~~~++The "link info" is a string representing the parameters of the link. We save+this information in the binary, and the next time we link, if nothing else has+changed, we use the link info stored in the existing binary to decide whether+to re-link or not.++The "link info" string is stored in a ELF section called ".debug-ghc-link-info"+(see ghcLinkInfoSectionName) with the SHT_NOTE type. For some time, it used to+not follow the specified record-based format (see #11022).++-}++haveRtsOptsFlags :: DynFlags -> Bool+haveRtsOptsFlags dflags =+ isJust (rtsOpts dflags) || case rtsOptsEnabled dflags of+ RtsOptsSafeOnly -> False+ _ -> True
+ main/SysTools/Info.hs view
@@ -0,0 +1,260 @@+{-# LANGUAGE ScopedTypeVariables #-}+-----------------------------------------------------------------------------+--+-- Compiler information functions+--+-- (c) The GHC Team 2017+--+-----------------------------------------------------------------------------+module SysTools.Info where++import Exception+import ErrUtils+import DynFlags+import Outputable+import Util++import Data.List+import Data.IORef++import System.IO++import Platform+import GhcPrelude++import SysTools.Process++{- Note [Run-time linker info]++See also: Trac #5240, Trac #6063, Trac #10110++Before 'runLink', we need to be sure to get the relevant information+about the linker we're using at runtime to see if we need any extra+options. For example, GNU ld requires '--reduce-memory-overheads' and+'--hash-size=31' in order to use reasonable amounts of memory (see+trac #5240.) But this isn't supported in GNU gold.++Generally, the linker changing from what was detected at ./configure+time has always been possible using -pgml, but on Linux it can happen+'transparently' by installing packages like binutils-gold, which+change what /usr/bin/ld actually points to.++Clang vs GCC notes:++For gcc, 'gcc -Wl,--version' gives a bunch of output about how to+invoke the linker before the version information string. For 'clang',+the version information for 'ld' is all that's output. For this+reason, we typically need to slurp up all of the standard error output+and look through it.++Other notes:++We cache the LinkerInfo inside DynFlags, since clients may link+multiple times. The definition of LinkerInfo is there to avoid a+circular dependency.++-}++{- Note [ELF needed shared libs]++Some distributions change the link editor's default handling of+ELF DT_NEEDED tags to include only those shared objects that are+needed to resolve undefined symbols. For Template Haskell we need+the last temporary shared library also if it is not needed for the+currently linked temporary shared library. We specify --no-as-needed+to override the default. This flag exists in GNU ld and GNU gold.++The flag is only needed on ELF systems. On Windows (PE) and Mac OS X+(Mach-O) the flag is not needed.++-}++{- Note [Windows static libGCC]++The GCC versions being upgraded to in #10726 are configured with+dynamic linking of libgcc supported. This results in libgcc being+linked dynamically when a shared library is created.++This introduces thus an extra dependency on GCC dll that was not+needed before by shared libraries created with GHC. This is a particular+issue on Windows because you get a non-obvious error due to this missing+dependency. This dependent dll is also not commonly on your path.++For this reason using the static libgcc is preferred as it preserves+the same behaviour that existed before. There are however some very good+reasons to have the shared version as well as described on page 181 of+https://gcc.gnu.org/onlinedocs/gcc-5.2.0/gcc.pdf :++"There are several situations in which an application should use the+ shared ‘libgcc’ instead of the static version. The most common of these+ is when the application wishes to throw and catch exceptions across different+ shared libraries. In that case, each of the libraries as well as the application+ itself should use the shared ‘libgcc’. "++-}++neededLinkArgs :: LinkerInfo -> [Option]+neededLinkArgs (GnuLD o) = o+neededLinkArgs (GnuGold o) = o+neededLinkArgs (LlvmLLD o) = o+neededLinkArgs (DarwinLD o) = o+neededLinkArgs (SolarisLD o) = o+neededLinkArgs (AixLD o) = o+neededLinkArgs UnknownLD = []++-- Grab linker info and cache it in DynFlags.+getLinkerInfo :: DynFlags -> IO LinkerInfo+getLinkerInfo dflags = do+ info <- readIORef (rtldInfo dflags)+ case info of+ Just v -> return v+ Nothing -> do+ v <- getLinkerInfo' dflags+ writeIORef (rtldInfo dflags) (Just v)+ return v++-- See Note [Run-time linker info].+getLinkerInfo' :: DynFlags -> IO LinkerInfo+getLinkerInfo' dflags = do+ let platform = targetPlatform dflags+ os = platformOS platform+ (pgm,args0) = pgm_l dflags+ args1 = map Option (getOpts dflags opt_l)+ args2 = args0 ++ args1+ args3 = filter notNull (map showOpt args2)++ -- Try to grab the info from the process output.+ parseLinkerInfo stdo _stde _exitc+ | any ("GNU ld" `isPrefixOf`) stdo =+ -- GNU ld specifically needs to use less memory. This especially+ -- hurts on small object files. Trac #5240.+ -- Set DT_NEEDED for all shared libraries. Trac #10110.+ -- TODO: Investigate if these help or hurt when using split sections.+ return (GnuLD $ map Option ["-Wl,--hash-size=31",+ "-Wl,--reduce-memory-overheads",+ -- ELF specific flag+ -- see Note [ELF needed shared libs]+ "-Wl,--no-as-needed"])++ | any ("GNU gold" `isPrefixOf`) stdo =+ -- GNU gold only needs --no-as-needed. Trac #10110.+ -- ELF specific flag, see Note [ELF needed shared libs]+ return (GnuGold [Option "-Wl,--no-as-needed"])++ | any ("LLD" `isPrefixOf`) stdo =+ return (LlvmLLD [])++ -- Unknown linker.+ | otherwise = fail "invalid --version output, or linker is unsupported"++ -- Process the executable call+ info <- catchIO (do+ case os of+ OSSolaris2 ->+ -- Solaris uses its own Solaris linker. Even all+ -- GNU C are recommended to configure with Solaris+ -- linker instead of using GNU binutils linker. Also+ -- all GCC distributed with Solaris follows this rule+ -- precisely so we assume here, the Solaris linker is+ -- used.+ return $ SolarisLD []+ OSAIX ->+ -- IBM AIX uses its own non-binutils linker as well+ return $ AixLD []+ OSDarwin ->+ -- Darwin has neither GNU Gold or GNU LD, but a strange linker+ -- that doesn't support --version. We can just assume that's+ -- what we're using.+ return $ DarwinLD []+ OSMinGW32 ->+ -- GHC doesn't support anything but GNU ld on Windows anyway.+ -- Process creation is also fairly expensive on win32, so+ -- we short-circuit here.+ return $ GnuLD $ map Option+ [ -- Reduce ld memory usage+ "-Wl,--hash-size=31"+ , "-Wl,--reduce-memory-overheads"+ -- Emit gcc stack checks+ -- Note [Windows stack usage]+ , "-fstack-check"+ -- Force static linking of libGCC+ -- Note [Windows static libGCC]+ , "-static-libgcc" ]+ _ -> do+ -- In practice, we use the compiler as the linker here. Pass+ -- -Wl,--version to get linker version info.+ (exitc, stdo, stde) <- readProcessEnvWithExitCode pgm+ (["-Wl,--version"] ++ args3)+ c_locale_env+ -- Split the output by lines to make certain kinds+ -- of processing easier. In particular, 'clang' and 'gcc'+ -- have slightly different outputs for '-Wl,--version', but+ -- it's still easy to figure out.+ parseLinkerInfo (lines stdo) (lines stde) exitc+ )+ (\err -> do+ debugTraceMsg dflags 2+ (text "Error (figuring out linker information):" <+>+ text (show err))+ errorMsg dflags $ hang (text "Warning:") 9 $+ text "Couldn't figure out linker information!" $$+ text "Make sure you're using GNU ld, GNU gold" <+>+ text "or the built in OS X linker, etc."+ return UnknownLD)+ return info++-- Grab compiler info and cache it in DynFlags.+getCompilerInfo :: DynFlags -> IO CompilerInfo+getCompilerInfo dflags = do+ info <- readIORef (rtccInfo dflags)+ case info of+ Just v -> return v+ Nothing -> do+ v <- getCompilerInfo' dflags+ writeIORef (rtccInfo dflags) (Just v)+ return v++-- See Note [Run-time linker info].+getCompilerInfo' :: DynFlags -> IO CompilerInfo+getCompilerInfo' dflags = do+ let (pgm,_) = pgm_c dflags+ -- Try to grab the info from the process output.+ parseCompilerInfo _stdo stde _exitc+ -- Regular GCC+ | any ("gcc version" `isInfixOf`) stde =+ return GCC+ -- Regular clang+ | any ("clang version" `isInfixOf`) stde =+ return Clang+ -- FreeBSD clang+ | any ("FreeBSD clang version" `isInfixOf`) stde =+ return Clang+ -- XCode 5.1 clang+ | any ("Apple LLVM version 5.1" `isPrefixOf`) stde =+ return AppleClang51+ -- XCode 5 clang+ | any ("Apple LLVM version" `isPrefixOf`) stde =+ return AppleClang+ -- XCode 4.1 clang+ | any ("Apple clang version" `isPrefixOf`) stde =+ return AppleClang+ -- Unknown linker.+ | otherwise = fail "invalid -v output, or compiler is unsupported"++ -- Process the executable call+ info <- catchIO (do+ (exitc, stdo, stde) <-+ readProcessEnvWithExitCode pgm ["-v"] c_locale_env+ -- Split the output by lines to make certain kinds+ -- of processing easier.+ parseCompilerInfo (lines stdo) (lines stde) exitc+ )+ (\err -> do+ debugTraceMsg dflags 2+ (text "Error (figuring out C compiler information):" <+>+ text (show err))+ errorMsg dflags $ hang (text "Warning:") 9 $+ text "Couldn't figure out C compiler information!" $$+ text "Make sure you're using GNU gcc, or clang"+ return UnknownCC)+ return info
+ main/SysTools/Process.hs view
@@ -0,0 +1,347 @@+{-# LANGUAGE CPP #-}+-----------------------------------------------------------------------------+--+-- Misc process handling code for SysTools+--+-- (c) The GHC Team 2017+--+-----------------------------------------------------------------------------+module SysTools.Process where++#include "HsVersions.h"++import Exception+import ErrUtils+import DynFlags+import FastString+import Outputable+import Panic+import GhcPrelude+import Util+import SrcLoc ( SrcLoc, mkSrcLoc, noSrcSpan, mkSrcSpan )++import Control.Concurrent+import Data.Char++import System.Exit+import System.Environment+import System.FilePath+import System.IO+import System.IO.Error as IO+import System.Process++import FileCleanup++-- Similar to System.Process.readCreateProcessWithExitCode, but stderr is+-- inherited from the parent process, and output to stderr is not captured.+readCreateProcessWithExitCode'+ :: CreateProcess+ -> IO (ExitCode, String) -- ^ stdout+readCreateProcessWithExitCode' proc = do+ (_, Just outh, _, pid) <-+ createProcess proc{ std_out = CreatePipe }++ -- fork off a thread to start consuming the output+ output <- hGetContents outh+ outMVar <- newEmptyMVar+ _ <- forkIO $ evaluate (length output) >> putMVar outMVar ()++ -- wait on the output+ takeMVar outMVar+ hClose outh++ -- wait on the process+ ex <- waitForProcess pid++ return (ex, output)++replaceVar :: (String, String) -> [(String, String)] -> [(String, String)]+replaceVar (var, value) env =+ (var, value) : filter (\(var',_) -> var /= var') env++-- | Version of @System.Process.readProcessWithExitCode@ that takes a+-- key-value tuple to insert into the environment.+readProcessEnvWithExitCode+ :: String -- ^ program path+ -> [String] -- ^ program args+ -> (String, String) -- ^ addition to the environment+ -> IO (ExitCode, String, String) -- ^ (exit_code, stdout, stderr)+readProcessEnvWithExitCode prog args env_update = do+ current_env <- getEnvironment+ readCreateProcessWithExitCode (proc prog args) {+ env = Just (replaceVar env_update current_env) } ""++-- Don't let gcc localize version info string, #8825+c_locale_env :: (String, String)+c_locale_env = ("LANGUAGE", "C")++-- If the -B<dir> option is set, add <dir> to PATH. This works around+-- a bug in gcc on Windows Vista where it can't find its auxiliary+-- binaries (see bug #1110).+getGccEnv :: [Option] -> IO (Maybe [(String,String)])+getGccEnv opts =+ if null b_dirs+ then return Nothing+ else do env <- getEnvironment+ return (Just (map mangle_path env))+ where+ (b_dirs, _) = partitionWith get_b_opt opts++ get_b_opt (Option ('-':'B':dir)) = Left dir+ get_b_opt other = Right other++ mangle_path (path,paths) | map toUpper path == "PATH"+ = (path, '\"' : head b_dirs ++ "\";" ++ paths)+ mangle_path other = other+++-----------------------------------------------------------------------------+-- Running an external program++runSomething :: DynFlags+ -> String -- For -v message+ -> String -- Command name (possibly a full path)+ -- assumed already dos-ified+ -> [Option] -- Arguments+ -- runSomething will dos-ify them+ -> IO ()++runSomething dflags phase_name pgm args =+ runSomethingFiltered dflags id phase_name pgm args Nothing Nothing++-- | Run a command, placing the arguments in an external response file.+--+-- This command is used in order to avoid overlong command line arguments on+-- Windows. The command line arguments are first written to an external,+-- temporary response file, and then passed to the linker via @filepath.+-- response files for passing them in. See:+--+-- https://gcc.gnu.org/wiki/Response_Files+-- https://ghc.haskell.org/trac/ghc/ticket/10777+runSomethingResponseFile+ :: DynFlags -> (String->String) -> String -> String -> [Option]+ -> Maybe [(String,String)] -> IO ()++runSomethingResponseFile dflags filter_fn phase_name pgm args mb_env =+ runSomethingWith dflags phase_name pgm args $ \real_args -> do+ fp <- getResponseFile real_args+ let args = ['@':fp]+ r <- builderMainLoop dflags filter_fn pgm args Nothing mb_env+ return (r,())+ where+ getResponseFile args = do+ fp <- newTempName dflags TFL_CurrentModule "rsp"+ withFile fp WriteMode $ \h -> do+#if defined(mingw32_HOST_OS)+ hSetEncoding h latin1+#else+ hSetEncoding h utf8+#endif+ hPutStr h $ unlines $ map escape args+ return fp++ -- Note: Response files have backslash-escaping, double quoting, and are+ -- whitespace separated (some implementations use newline, others any+ -- whitespace character). Therefore, escape any backslashes, newlines, and+ -- double quotes in the argument, and surround the content with double+ -- quotes.+ --+ -- Another possibility that could be considered would be to convert+ -- backslashes in the argument to forward slashes. This would generally do+ -- the right thing, since backslashes in general only appear in arguments+ -- as part of file paths on Windows, and the forward slash is accepted for+ -- those. However, escaping is more reliable, in case somehow a backslash+ -- appears in a non-file.+ escape x = concat+ [ "\""+ , concatMap+ (\c ->+ case c of+ '\\' -> "\\\\"+ '\n' -> "\\n"+ '\"' -> "\\\""+ _ -> [c])+ x+ , "\""+ ]++runSomethingFiltered+ :: DynFlags -> (String->String) -> String -> String -> [Option]+ -> Maybe FilePath -> Maybe [(String,String)] -> IO ()++runSomethingFiltered dflags filter_fn phase_name pgm args mb_cwd mb_env = do+ runSomethingWith dflags phase_name pgm args $ \real_args -> do+ r <- builderMainLoop dflags filter_fn pgm real_args mb_cwd mb_env+ return (r,())++runSomethingWith+ :: DynFlags -> String -> String -> [Option]+ -> ([String] -> IO (ExitCode, a))+ -> IO a++runSomethingWith dflags phase_name pgm args io = do+ let real_args = filter notNull (map showOpt args)+ cmdLine = showCommandForUser pgm real_args+ traceCmd dflags phase_name cmdLine $ handleProc pgm phase_name $ io real_args++handleProc :: String -> String -> IO (ExitCode, r) -> IO r+handleProc pgm phase_name proc = do+ (rc, r) <- proc `catchIO` handler+ case rc of+ ExitSuccess{} -> return r+ ExitFailure n -> throwGhcExceptionIO (+ ProgramError ("`" ++ takeFileName pgm ++ "'" +++ " failed in phase `" ++ phase_name ++ "'." +++ " (Exit code: " ++ show n ++ ")"))+ where+ handler err =+ if IO.isDoesNotExistError err+ then does_not_exist+ else throwGhcExceptionIO (ProgramError $ show err)++ does_not_exist = throwGhcExceptionIO (InstallationError ("could not execute: " ++ pgm))+++builderMainLoop :: DynFlags -> (String -> String) -> FilePath+ -> [String] -> Maybe FilePath -> Maybe [(String, String)]+ -> IO ExitCode+builderMainLoop dflags filter_fn pgm real_args mb_cwd mb_env = do+ chan <- newChan++ -- We use a mask here rather than a bracket because we want+ -- to distinguish between cleaning up with and without an+ -- exception. This is to avoid calling terminateProcess+ -- unless an exception was raised.+ let safely inner = mask $ \restore -> do+ -- acquire+ (hStdIn, hStdOut, hStdErr, hProcess) <- restore $+ runInteractiveProcess pgm real_args mb_cwd mb_env+ let cleanup_handles = do+ hClose hStdIn+ hClose hStdOut+ hClose hStdErr+ r <- try $ restore $ do+ hSetBuffering hStdOut LineBuffering+ hSetBuffering hStdErr LineBuffering+ let make_reader_proc h = forkIO $ readerProc chan h filter_fn+ bracketOnError (make_reader_proc hStdOut) killThread $ \_ ->+ bracketOnError (make_reader_proc hStdErr) killThread $ \_ ->+ inner hProcess+ case r of+ -- onException+ Left (SomeException e) -> do+ terminateProcess hProcess+ cleanup_handles+ throw e+ -- cleanup when there was no exception+ Right s -> do+ cleanup_handles+ return s+ safely $ \h -> do+ -- we don't want to finish until 2 streams have been complete+ -- (stdout and stderr)+ log_loop chan (2 :: Integer)+ -- after that, we wait for the process to finish and return the exit code.+ waitForProcess h+ where+ -- t starts at the number of streams we're listening to (2) decrements each+ -- time a reader process sends EOF. We are safe from looping forever if a+ -- reader thread dies, because they send EOF in a finally handler.+ log_loop _ 0 = return ()+ log_loop chan t = do+ msg <- readChan chan+ case msg of+ BuildMsg msg -> do+ putLogMsg dflags NoReason SevInfo noSrcSpan+ (defaultUserStyle dflags) msg+ log_loop chan t+ BuildError loc msg -> do+ putLogMsg dflags NoReason SevError (mkSrcSpan loc loc)+ (defaultUserStyle dflags) msg+ log_loop chan t+ EOF ->+ log_loop chan (t-1)++readerProc :: Chan BuildMessage -> Handle -> (String -> String) -> IO ()+readerProc chan hdl filter_fn =+ (do str <- hGetContents hdl+ loop (linesPlatform (filter_fn str)) Nothing)+ `finally`+ writeChan chan EOF+ -- ToDo: check errors more carefully+ -- ToDo: in the future, the filter should be implemented as+ -- a stream transformer.+ where+ loop [] Nothing = return ()+ loop [] (Just err) = writeChan chan err+ loop (l:ls) in_err =+ case in_err of+ Just err@(BuildError srcLoc msg)+ | leading_whitespace l -> do+ loop ls (Just (BuildError srcLoc (msg $$ text l)))+ | otherwise -> do+ writeChan chan err+ checkError l ls+ Nothing -> do+ checkError l ls+ _ -> panic "readerProc/loop"++ checkError l ls+ = case parseError l of+ Nothing -> do+ writeChan chan (BuildMsg (text l))+ loop ls Nothing+ Just (file, lineNum, colNum, msg) -> do+ let srcLoc = mkSrcLoc (mkFastString file) lineNum colNum+ loop ls (Just (BuildError srcLoc (text msg)))++ leading_whitespace [] = False+ leading_whitespace (x:_) = isSpace x++parseError :: String -> Maybe (String, Int, Int, String)+parseError s0 = case breakColon s0 of+ Just (filename, s1) ->+ case breakIntColon s1 of+ Just (lineNum, s2) ->+ case breakIntColon s2 of+ Just (columnNum, s3) ->+ Just (filename, lineNum, columnNum, s3)+ Nothing ->+ Just (filename, lineNum, 0, s2)+ Nothing -> Nothing+ Nothing -> Nothing++breakColon :: String -> Maybe (String, String)+breakColon xs = case break (':' ==) xs of+ (ys, _:zs) -> Just (ys, zs)+ _ -> Nothing++breakIntColon :: String -> Maybe (Int, String)+breakIntColon xs = case break (':' ==) xs of+ (ys, _:zs)+ | not (null ys) && all isAscii ys && all isDigit ys ->+ Just (read ys, zs)+ _ -> Nothing++data BuildMessage+ = BuildMsg !SDoc+ | BuildError !SrcLoc !SDoc+ | EOF++-- Divvy up text stream into lines, taking platform dependent+-- line termination into account.+linesPlatform :: String -> [String]+#if !defined(mingw32_HOST_OS)+linesPlatform ls = lines ls+#else+linesPlatform "" = []+linesPlatform xs =+ case lineBreak xs of+ (as,xs1) -> as : linesPlatform xs1+ where+ lineBreak "" = ("","")+ lineBreak ('\r':'\n':xs) = ([],xs)+ lineBreak ('\n':xs) = ([],xs)+ lineBreak (x:xs) = let (as,bs) = lineBreak xs in (x:as,bs)++#endif
+ main/SysTools/Tasks.hs view
@@ -0,0 +1,343 @@+{-# LANGUAGE ScopedTypeVariables #-}+-----------------------------------------------------------------------------+--+-- Tasks running external programs for SysTools+--+-- (c) The GHC Team 2017+--+-----------------------------------------------------------------------------+module SysTools.Tasks where++import Exception+import ErrUtils+import DynFlags+import Outputable+import Platform+import Util++import Data.Char+import Data.List++import System.IO+import System.Process+import GhcPrelude++import LlvmCodeGen.Base (llvmVersionStr, supportedLlvmVersion)++import SysTools.Process+import SysTools.Info++{-+************************************************************************+* *+\subsection{Running an external program}+* *+************************************************************************+-}++runUnlit :: DynFlags -> [Option] -> IO ()+runUnlit dflags args = do+ let prog = pgm_L dflags+ opts = getOpts dflags opt_L+ runSomething dflags "Literate pre-processor" prog+ (map Option opts ++ args)++runCpp :: DynFlags -> [Option] -> IO ()+runCpp dflags args = do+ let (p,args0) = pgm_P dflags+ args1 = map Option (getOpts dflags opt_P)+ args2 = [Option "-Werror" | gopt Opt_WarnIsError dflags]+ ++ [Option "-Wundef" | wopt Opt_WarnCPPUndef dflags]+ mb_env <- getGccEnv args2+ runSomethingFiltered dflags id "C pre-processor" p+ (args0 ++ args1 ++ args2 ++ args) Nothing mb_env++runPp :: DynFlags -> [Option] -> IO ()+runPp dflags args = do+ let prog = pgm_F dflags+ opts = map Option (getOpts dflags opt_F)+ runSomething dflags "Haskell pre-processor" prog (args ++ opts)++runCc :: DynFlags -> [Option] -> IO ()+runCc dflags args = do+ let (p,args0) = pgm_c dflags+ args1 = map Option (getOpts dflags opt_c)+ args2 = args0 ++ args1 ++ args+ mb_env <- getGccEnv args2+ runSomethingResponseFile dflags cc_filter "C Compiler" p args2 mb_env+ where+ -- discard some harmless warnings from gcc that we can't turn off+ cc_filter = unlines . doFilter . lines++ {-+ gcc gives warnings in chunks like so:+ In file included from /foo/bar/baz.h:11,+ from /foo/bar/baz2.h:22,+ from wibble.c:33:+ /foo/flibble:14: global register variable ...+ /foo/flibble:15: warning: call-clobbered r...+ We break it up into its chunks, remove any call-clobbered register+ warnings from each chunk, and then delete any chunks that we have+ emptied of warnings.+ -}+ doFilter = unChunkWarnings . filterWarnings . chunkWarnings []+ -- We can't assume that the output will start with an "In file inc..."+ -- line, so we start off expecting a list of warnings rather than a+ -- location stack.+ chunkWarnings :: [String] -- The location stack to use for the next+ -- list of warnings+ -> [String] -- The remaining lines to look at+ -> [([String], [String])]+ chunkWarnings loc_stack [] = [(loc_stack, [])]+ chunkWarnings loc_stack xs+ = case break loc_stack_start xs of+ (warnings, lss:xs') ->+ case span loc_start_continuation xs' of+ (lsc, xs'') ->+ (loc_stack, warnings) : chunkWarnings (lss : lsc) xs''+ _ -> [(loc_stack, xs)]++ filterWarnings :: [([String], [String])] -> [([String], [String])]+ filterWarnings [] = []+ -- If the warnings are already empty then we are probably doing+ -- something wrong, so don't delete anything+ filterWarnings ((xs, []) : zs) = (xs, []) : filterWarnings zs+ filterWarnings ((xs, ys) : zs) = case filter wantedWarning ys of+ [] -> filterWarnings zs+ ys' -> (xs, ys') : filterWarnings zs++ unChunkWarnings :: [([String], [String])] -> [String]+ unChunkWarnings [] = []+ unChunkWarnings ((xs, ys) : zs) = xs ++ ys ++ unChunkWarnings zs++ loc_stack_start s = "In file included from " `isPrefixOf` s+ loc_start_continuation s = " from " `isPrefixOf` s+ wantedWarning w+ | "warning: call-clobbered register used" `isContainedIn` w = False+ | otherwise = True++isContainedIn :: String -> String -> Bool+xs `isContainedIn` ys = any (xs `isPrefixOf`) (tails ys)++-- | Run the linker with some arguments and return the output+askLd :: DynFlags -> [Option] -> IO String+askLd dflags args = do+ let (p,args0) = pgm_l dflags+ args1 = map Option (getOpts dflags opt_l)+ args2 = args0 ++ args1 ++ args+ mb_env <- getGccEnv args2+ runSomethingWith dflags "gcc" p args2 $ \real_args ->+ readCreateProcessWithExitCode' (proc p real_args){ env = mb_env }++runSplit :: DynFlags -> [Option] -> IO ()+runSplit dflags args = do+ let (p,args0) = pgm_s dflags+ runSomething dflags "Splitter" p (args0++args)++runAs :: DynFlags -> [Option] -> IO ()+runAs dflags args = do+ let (p,args0) = pgm_a dflags+ args1 = map Option (getOpts dflags opt_a)+ args2 = args0 ++ args1 ++ args+ mb_env <- getGccEnv args2+ runSomethingFiltered dflags id "Assembler" p args2 Nothing mb_env++-- | Run the LLVM Optimiser+runLlvmOpt :: DynFlags -> [Option] -> IO ()+runLlvmOpt dflags args = do+ let (p,args0) = pgm_lo dflags+ args1 = map Option (getOpts dflags opt_lo)+ runSomething dflags "LLVM Optimiser" p (args0 ++ args1 ++ args)++-- | Run the LLVM Compiler+runLlvmLlc :: DynFlags -> [Option] -> IO ()+runLlvmLlc dflags args = do+ let (p,args0) = pgm_lc dflags+ args1 = map Option (getOpts dflags opt_lc)+ runSomething dflags "LLVM Compiler" p (args0 ++ args1 ++ args)++-- | Run the clang compiler (used as an assembler for the LLVM+-- backend on OS X as LLVM doesn't support the OS X system+-- assembler)+runClang :: DynFlags -> [Option] -> IO ()+runClang dflags args = do+ let (clang,_) = pgm_lcc dflags+ -- be careful what options we call clang with+ -- see #5903 and #7617 for bugs caused by this.+ (_,args0) = pgm_a dflags+ args1 = map Option (getOpts dflags opt_a)+ args2 = args0 ++ args1 ++ args+ mb_env <- getGccEnv args2+ Exception.catch (do+ runSomethingFiltered dflags id "Clang (Assembler)" clang args2 Nothing mb_env+ )+ (\(err :: SomeException) -> do+ errorMsg dflags $+ text ("Error running clang! you need clang installed to use the" +++ " LLVM backend") $+$+ text "(or GHC tried to execute clang incorrectly)"+ throwIO err+ )++-- | Figure out which version of LLVM we are running this session+figureLlvmVersion :: DynFlags -> IO (Maybe (Int, Int))+figureLlvmVersion dflags = do+ let (pgm,opts) = pgm_lc dflags+ args = filter notNull (map showOpt opts)+ -- we grab the args even though they should be useless just in+ -- case the user is using a customised 'llc' that requires some+ -- of the options they've specified. llc doesn't care what other+ -- options are specified when '-version' is used.+ args' = args ++ ["-version"]+ ver <- catchIO (do+ (pin, pout, perr, _) <- runInteractiveProcess pgm args'+ Nothing Nothing+ {- > llc -version+ LLVM (http://llvm.org/):+ LLVM version 3.5.2+ ...+ -}+ hSetBinaryMode pout False+ _ <- hGetLine pout+ vline <- dropWhile (not . isDigit) `fmap` hGetLine pout+ v <- case span (/= '.') vline of+ ("",_) -> fail "no digits!"+ (x,y) -> return (read x+ , read $ takeWhile isDigit $ drop 1 y)++ hClose pin+ hClose pout+ hClose perr+ return $ Just v+ )+ (\err -> do+ debugTraceMsg dflags 2+ (text "Error (figuring out LLVM version):" <+>+ text (show err))+ errorMsg dflags $ vcat+ [ text "Warning:", nest 9 $+ text "Couldn't figure out LLVM version!" $$+ text ("Make sure you have installed LLVM " +++ llvmVersionStr supportedLlvmVersion) ]+ return Nothing)+ return ver+++runLink :: DynFlags -> [Option] -> IO ()+runLink dflags args = do+ -- See Note [Run-time linker info]+ linkargs <- neededLinkArgs `fmap` getLinkerInfo dflags+ let (p,args0) = pgm_l dflags+ args1 = map Option (getOpts dflags opt_l)+ args2 = args0 ++ linkargs ++ args1 ++ args+ mb_env <- getGccEnv args2+ runSomethingResponseFile dflags ld_filter "Linker" p args2 mb_env+ where+ ld_filter = case (platformOS (targetPlatform dflags)) of+ OSSolaris2 -> sunos_ld_filter+ _ -> id+{-+ SunOS/Solaris ld emits harmless warning messages about unresolved+ symbols in case of compiling into shared library when we do not+ link against all the required libs. That is the case of GHC which+ does not link against RTS library explicitly in order to be able to+ choose the library later based on binary application linking+ parameters. The warnings look like:++Undefined first referenced+ symbol in file+stg_ap_n_fast ./T2386_Lib.o+stg_upd_frame_info ./T2386_Lib.o+templatezmhaskell_LanguageziHaskellziTHziLib_litE_closure ./T2386_Lib.o+templatezmhaskell_LanguageziHaskellziTHziLib_appE_closure ./T2386_Lib.o+templatezmhaskell_LanguageziHaskellziTHziLib_conE_closure ./T2386_Lib.o+templatezmhaskell_LanguageziHaskellziTHziSyntax_mkNameGzud_closure ./T2386_Lib.o+newCAF ./T2386_Lib.o+stg_bh_upd_frame_info ./T2386_Lib.o+stg_ap_ppp_fast ./T2386_Lib.o+templatezmhaskell_LanguageziHaskellziTHziLib_stringL_closure ./T2386_Lib.o+stg_ap_p_fast ./T2386_Lib.o+stg_ap_pp_fast ./T2386_Lib.o+ld: warning: symbol referencing errors++ this is actually coming from T2386 testcase. The emitting of those+ warnings is also a reason why so many TH testcases fail on Solaris.++ Following filter code is SunOS/Solaris linker specific and should+ filter out only linker warnings. Please note that the logic is a+ little bit more complex due to the simple reason that we need to preserve+ any other linker emitted messages. If there are any. Simply speaking+ if we see "Undefined" and later "ld: warning:..." then we omit all+ text between (including) the marks. Otherwise we copy the whole output.+-}+ sunos_ld_filter :: String -> String+ sunos_ld_filter = unlines . sunos_ld_filter' . lines+ sunos_ld_filter' x = if (undefined_found x && ld_warning_found x)+ then (ld_prefix x) ++ (ld_postfix x)+ else x+ breakStartsWith x y = break (isPrefixOf x) y+ ld_prefix = fst . breakStartsWith "Undefined"+ undefined_found = not . null . snd . breakStartsWith "Undefined"+ ld_warn_break = breakStartsWith "ld: warning: symbol referencing errors"+ ld_postfix = tail . snd . ld_warn_break+ ld_warning_found = not . null . snd . ld_warn_break+++runLibtool :: DynFlags -> [Option] -> IO ()+runLibtool dflags args = do+ linkargs <- neededLinkArgs `fmap` getLinkerInfo dflags+ let args1 = map Option (getOpts dflags opt_l)+ args2 = [Option "-static"] ++ args1 ++ args ++ linkargs+ libtool = pgm_libtool dflags+ mb_env <- getGccEnv args2+ runSomethingFiltered dflags id "Linker" libtool args2 Nothing mb_env++runAr :: DynFlags -> Maybe FilePath -> [Option] -> IO ()+runAr dflags cwd args = do+ let ar = pgm_ar dflags+ runSomethingFiltered dflags id "Ar" ar args cwd Nothing++askAr :: DynFlags -> Maybe FilePath -> [Option] -> IO String+askAr dflags mb_cwd args = do+ let ar = pgm_ar dflags+ runSomethingWith dflags "Ar" ar args $ \real_args ->+ readCreateProcessWithExitCode' (proc ar real_args){ cwd = mb_cwd }++runRanlib :: DynFlags -> [Option] -> IO ()+runRanlib dflags args = do+ let ranlib = pgm_ranlib dflags+ runSomethingFiltered dflags id "Ranlib" ranlib args Nothing Nothing++runMkDLL :: DynFlags -> [Option] -> IO ()+runMkDLL dflags args = do+ let (p,args0) = pgm_dll dflags+ args1 = args0 ++ args+ mb_env <- getGccEnv (args0++args)+ runSomethingFiltered dflags id "Make DLL" p args1 Nothing mb_env++runWindres :: DynFlags -> [Option] -> IO ()+runWindres dflags args = do+ let (gcc, gcc_args) = pgm_c dflags+ windres = pgm_windres dflags+ opts = map Option (getOpts dflags opt_windres)+ quote x = "\"" ++ x ++ "\""+ args' = -- If windres.exe and gcc.exe are in a directory containing+ -- spaces then windres fails to run gcc. We therefore need+ -- to tell it what command to use...+ Option ("--preprocessor=" +++ unwords (map quote (gcc :+ map showOpt gcc_args +++ map showOpt opts +++ ["-E", "-xc", "-DRC_INVOKED"])))+ -- ...but if we do that then if windres calls popen then+ -- it can't understand the quoting, so we have to use+ -- --use-temp-file so that it interprets it correctly.+ -- See #1828.+ : Option "--use-temp-file"+ : args+ mb_env <- getGccEnv gcc_args+ runSomethingFiltered dflags id "Windres" windres args' Nothing mb_env++touch :: DynFlags -> String -> String -> IO ()+touch dflags purpose arg =+ runSomething dflags purpose (pgm_T dflags) [FileOption "" arg]
main/SysTools/Terminal.hs view
@@ -1,6 +1,9 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE ScopedTypeVariables #-} module SysTools.Terminal (stderrSupportsAnsiColors) where++import GhcPrelude+ #if defined MIN_VERSION_terminfo import Control.Exception (catch) import Data.Maybe (fromMaybe)
main/TidyPgm.hs view
@@ -12,6 +12,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TcRnTypes import DynFlags import CoreSyn@@ -200,7 +202,7 @@ globaliseAndTidyId :: Id -> Id--- Takes an LocalId with an External Name,+-- Takes a LocalId with an External Name, -- makes it into a GlobalId -- * unchanged Name (might be Internal or External) -- * unchanged details
nativeGen/AsmCodeGen.hs view
@@ -25,6 +25,8 @@ #include "nativeGen/NCG.h" +import GhcPrelude+ import qualified X86.CodeGen import qualified X86.Regs import qualified X86.Instr@@ -51,6 +53,7 @@ import qualified RegAlloc.Graph.Stats as Color import qualified RegAlloc.Graph.TrivColorable as Color +import AsmUtils import TargetReg import Platform import Config@@ -65,7 +68,9 @@ import CgUtils ( fixStgRegisters ) import Cmm import CmmUtils-import Hoopl+import Hoopl.Collections+import Hoopl.Label+import Hoopl.Block import CmmOpt ( cmmMachOpFold ) import PprCmm import CLabel@@ -768,7 +773,7 @@ -- security. GHC generated code does not need an executable -- stack so add the note in: (if platformHasGnuNonexecStack platform- then text ".section .note.GNU-stack,\"\",@progbits"+ then text ".section .note.GNU-stack,\"\"," <> sectionType "progbits" else Outputable.empty) $$ -- And just because every other compiler does, let's stick in@@ -848,9 +853,7 @@ sccBlocks :: Instruction instr => [NatBasicBlock instr]- -> [SCC ( NatBasicBlock instr- , BlockId- , [BlockId])]+ -> [SCC (Node BlockId (NatBasicBlock instr))] sccBlocks blocks = stronglyConnCompFromEdgedVerticesUniqR (map mkNode blocks) @@ -867,10 +870,10 @@ mkNode :: (Instruction t) => GenBasicBlock t- -> (GenBasicBlock t, BlockId, [BlockId])-mkNode block@(BasicBlock id instrs) = (block, id, getOutEdges instrs)+ -> Node BlockId (GenBasicBlock t)+mkNode block@(BasicBlock id instrs) = DigraphNode block id (getOutEdges instrs) -seqBlocks :: LabelMap i -> [(GenBasicBlock t1, BlockId, [BlockId])]+seqBlocks :: LabelMap i -> [Node BlockId (GenBasicBlock t1)] -> [GenBasicBlock t1] seqBlocks infos blocks = placeNext pullable0 todo0 where@@ -879,8 +882,8 @@ -- reason not to; -- may include blocks that have already been placed, but then -- these are not in pullable- pullable0 = listToUFM [ (i,(b,n)) | (b,i,n) <- blocks ]- todo0 = [i | (_,i,_) <- blocks ]+ pullable0 = listToUFM [ (i,(b,n)) | DigraphNode b i n <- blocks ]+ todo0 = map node_key blocks placeNext _ [] = [] placeNext pullable (i:rest)@@ -926,7 +929,7 @@ shortcutBranches :: DynFlags- -> NcgImpl statics instr jumpDest+ -> NcgImpl statics instr jumpDest -> [NatCmmDecl statics instr] -> [NatCmmDecl statics instr] @@ -935,7 +938,7 @@ | otherwise = map (apply_mapping ncgImpl mapping) tops' where (tops', mappings) = mapAndUnzip (build_mapping ncgImpl) tops- mapping = foldr plusUFM emptyUFM mappings+ mapping = plusUFMList mappings build_mapping :: NcgImpl statics instr jumpDest -> GenCmmDecl d (LabelMap t) (ListGraph instr)@@ -969,7 +972,7 @@ has_info l = mapMember l info -- build a mapping from BlockId to JumpDest for shorting branches- mapping = foldl add emptyUFM shortcut_blocks+ mapping = foldl' add emptyUFM shortcut_blocks add ufm (id,dest) = addToUFM ufm id dest apply_mapping :: NcgImpl statics instr jumpDest
nativeGen/CPrim.hs view
@@ -5,12 +5,16 @@ , atomicRMWLabel , cmpxchgLabel , popCntLabel+ , pdepLabel+ , pextLabel , bSwapLabel , clzLabel , ctzLabel , word2FloatLabel ) where +import GhcPrelude+ import CmmType import CmmMachOp import Outputable@@ -23,6 +27,24 @@ pprWidth W32 = "32" pprWidth W64 = "64" pprWidth w = pprPanic "popCntLabel: Unsupported word width " (ppr w)++pdepLabel :: Width -> String+pdepLabel w = "hs_pdep" ++ pprWidth w+ where+ pprWidth W8 = "8"+ pprWidth W16 = "16"+ pprWidth W32 = "32"+ pprWidth W64 = "64"+ pprWidth w = pprPanic "pdepLabel: Unsupported word width " (ppr w)++pextLabel :: Width -> String+pextLabel w = "hs_pext" ++ pprWidth w+ where+ pprWidth W8 = "8"+ pprWidth W16 = "16"+ pprWidth W32 = "32"+ pprWidth W64 = "64"+ pprWidth w = pprPanic "pextLabel: Unsupported word width " (ppr w) bSwapLabel :: Width -> String bSwapLabel w = "hs_bswap" ++ pprWidth w
nativeGen/Dwarf.hs view
@@ -2,6 +2,8 @@ dwarfGen ) where +import GhcPrelude+ import CLabel import CmmExpr ( GlobalReg(..) ) import Config ( cProjectName, cProjectVersion )@@ -26,7 +28,8 @@ import System.FilePath import System.Directory ( getCurrentDirectory ) -import qualified Compiler.Hoopl as H+import qualified Hoopl.Label as H+import qualified Hoopl.Collections as H -- | Generate DWARF/debug information dwarfGen :: DynFlags -> ModLocation -> UniqSupply -> [DebugBlock]
nativeGen/Dwarf/Constants.hs view
@@ -3,6 +3,9 @@ module Dwarf.Constants where +import GhcPrelude++import AsmUtils import FastString import Platform import Outputable@@ -150,14 +153,15 @@ dwarfARangesSection = dwarfSection "aranges" dwarfSection :: String -> SDoc-dwarfSection name = sdocWithPlatform $ \plat -> ftext $ mkFastString $+dwarfSection name = sdocWithPlatform $ \plat -> case platformOS plat of os | osElfTarget os- -> "\t.section .debug_" ++ name ++ ",\"\",@progbits"+ -> text "\t.section .debug_" <> text name <> text ",\"\","+ <> sectionType "progbits" | osMachOTarget os- -> "\t.section __DWARF,__debug_" ++ name ++ ",regular,debug"+ -> text "\t.section __DWARF,__debug_" <> text name <> text ",regular,debug" | otherwise- -> "\t.section .debug_" ++ name ++ ",\"dr\""+ -> text "\t.section .debug_" <> text name <> text ",\"dr\"" -- * Dwarf section labels dwarfInfoLabel, dwarfAbbrevLabel, dwarfLineLabel, dwarfFrameLabel :: LitString
nativeGen/Dwarf/Types.hs view
@@ -22,6 +22,8 @@ ) where +import GhcPrelude+ import Debug import CLabel import CmmExpr ( GlobalReg(..) )@@ -32,6 +34,7 @@ import Unique import Reg import SrcLoc+import Util import Dwarf.Constants @@ -343,7 +346,7 @@ procEnd = mkAsmTempEndLabel procLbl ifInfo str = if hasInfo then text str else empty -- see [Note: Info Offset]- in vcat [ ifPprDebug $ text "# Unwinding for" <+> ppr procLbl <> colon+ in vcat [ whenPprDebug $ text "# Unwinding for" <+> ppr procLbl <> colon , pprData4' (ppr fdeEndLabel <> char '-' <> ppr fdeLabel) , ppr fdeLabel <> colon , pprData4' (ppr frameLbl <> char '-' <>@@ -570,7 +573,7 @@ pprString :: String -> SDoc pprString str = pprString' $ hcat $ map escapeChar $- if utf8EncodedLength str == length str+ if str `lengthIs` utf8EncodedLength str then str else map (chr . fromIntegral) $ bytesFS $ mkFastString str
nativeGen/Format.hs view
@@ -20,6 +20,8 @@ where +import GhcPrelude+ import Cmm import Outputable @@ -68,6 +70,7 @@ = case width of W32 -> FF32 W64 -> FF64+ W80 -> FF80 other -> pprPanic "Format.floatFormat" (ppr other)
nativeGen/Instruction.hs view
@@ -14,10 +14,13 @@ where +import GhcPrelude+ import Reg import BlockId-import Hoopl+import Hoopl.Collections+import Hoopl.Label import DynFlags import Cmm hiding (topInfoTable) import Platform
nativeGen/NCG.h view
@@ -6,9 +6,6 @@ -------------------------------------------------------------------------- */ -#ifndef NCG_H-#define NCG_H+#pragma once #include "ghc_boot_platform.h"--#endif
nativeGen/NCGMonad.hs view
@@ -37,13 +37,16 @@ #include "HsVersions.h" +import GhcPrelude+ import Reg import Format import TargetReg import BlockId-import Hoopl-import CLabel ( CLabel, mkAsmTempLabel )+import Hoopl.Collections+import Hoopl.Label+import CLabel ( CLabel ) import Debug import FastString ( FastString ) import UniqFM@@ -54,8 +57,6 @@ import Control.Monad ( liftM, ap ) -import Compiler.Hoopl ( LabelMap, Label )- data NatM_State = NatM_State { natm_us :: UniqSupply,@@ -159,8 +160,7 @@ getNewLabelNat :: NatM CLabel getNewLabelNat- = do u <- getUniqueNat- return (mkAsmTempLabel u)+ = blockLbl <$> getBlockIdNat getNewRegNat :: Format -> NatM Reg
nativeGen/PIC.hs view
@@ -47,6 +47,8 @@ where +import GhcPrelude+ import qualified PPC.Instr as PPC import qualified PPC.Regs as PPC @@ -58,7 +60,7 @@ import NCGMonad -import Hoopl+import Hoopl.Collections import Cmm import CLabel ( CLabel, ForeignLabelSource(..), pprCLabel, mkDynamicLinkerLabel, DynamicLinkerLabelInfo(..),
nativeGen/PPC/CodeGen.hs view
@@ -25,6 +25,8 @@ #include "MachDeps.h" -- NCG stuff:+import GhcPrelude+ import CodeGen.Platform import PPC.Instr import PPC.Cond@@ -46,12 +48,12 @@ import CmmUtils import CmmSwitch import CLabel-import Hoopl+import Hoopl.Block+import Hoopl.Graph -- The rest: import OrdList import Outputable-import Unique import DynFlags import Control.Monad ( mapAndUnzipM, when )@@ -89,13 +91,23 @@ case picBaseMb of Just picBase -> initializePicBase_ppc arch os picBase tops Nothing -> return tops- ArchPPC_64 ELF_V1 -> return tops+ ArchPPC_64 ELF_V1 -> fixup_entry tops -- generating function descriptor is handled in -- pretty printer- ArchPPC_64 ELF_V2 -> return tops+ ArchPPC_64 ELF_V2 -> fixup_entry tops -- generating function prologue is handled in -- pretty printer _ -> panic "PPC.cmmTopCodeGen: unknown arch"+ where+ fixup_entry (CmmProc info lab live (ListGraph (entry:blocks)) : statics)+ = do+ let BasicBlock bID insns = entry+ bID' <- if lab == (blockLbl bID)+ then newBlockId+ else return bID+ let b' = BasicBlock bID' insns+ return (CmmProc info lab live (ListGraph (b':blocks)) : statics)+ fixup_entry _ = panic "cmmTopCodegen: Broken CmmProc" cmmTopCodeGen (CmmData sec dat) = do return [CmmData sec dat] -- no translation, we just use CmmStatic@@ -160,8 +172,8 @@ -> genCCall target result_regs args CmmBranch id -> genBranch id- CmmCondBranch arg true false _ -> do- b1 <- genCondJump true arg+ CmmCondBranch arg true false prediction -> do+ b1 <- genCondJump true arg prediction b2 <- genBranch false return (b1 `appOL` b2) CmmSwitch arg ids -> do dflags <- getDynFlags@@ -213,7 +225,7 @@ jumpTableEntry :: DynFlags -> Maybe BlockId -> CmmStatic jumpTableEntry dflags Nothing = CmmStaticLit (CmmInt 0 (wordWidth dflags)) jumpTableEntry _ (Just blockid) = CmmStaticLit (CmmLabel blockLabel)- where blockLabel = mkAsmTempLabel (getUnique blockid)+ where blockLabel = blockLbl blockid @@ -718,7 +730,7 @@ = Amode AddrMode InstrBlock {--Now, given a tree (the argument to an CmmLoad) that references memory,+Now, given a tree (the argument to a CmmLoad) that references memory, produce a suitable addressing mode. A Rule of the Game (tm) for Amodes: use of the addr bit must@@ -1069,11 +1081,12 @@ genCondJump :: BlockId -- the branch target -> CmmExpr -- the condition on which to branch+ -> Maybe Bool -> NatM InstrBlock -genCondJump id bool = do+genCondJump id bool prediction = do CondCode _ cond code <- getCondCode bool- return (code `snocOL` BCC cond id)+ return (code `snocOL` BCC cond id prediction) @@ -1097,6 +1110,90 @@ genCCall (PrimTarget (MO_Prefetch_Data _)) _ _ = return $ nilOL +genCCall (PrimTarget (MO_AtomicRMW width amop)) [dst] [addr, n]+ = do dflags <- getDynFlags+ let platform = targetPlatform dflags+ fmt = intFormat width+ reg_dst = getRegisterReg platform (CmmLocal dst)+ (instr, n_code) <- case amop of+ AMO_Add -> getSomeRegOrImm ADD True reg_dst+ AMO_Sub -> case n of+ CmmLit (CmmInt i _)+ | Just imm <- makeImmediate width True (-i)+ -> return (ADD reg_dst reg_dst (RIImm imm), nilOL)+ _+ -> do+ (n_reg, n_code) <- getSomeReg n+ return (SUBF reg_dst n_reg reg_dst, n_code)+ AMO_And -> getSomeRegOrImm AND False reg_dst+ AMO_Nand -> do (n_reg, n_code) <- getSomeReg n+ return (NAND reg_dst reg_dst n_reg, n_code)+ AMO_Or -> getSomeRegOrImm OR False reg_dst+ AMO_Xor -> getSomeRegOrImm XOR False reg_dst+ Amode addr_reg addr_code <- getAmodeIndex addr+ lbl_retry <- getBlockIdNat+ return $ n_code `appOL` addr_code+ `appOL` toOL [ HWSYNC+ , BCC ALWAYS lbl_retry Nothing++ , NEWBLOCK lbl_retry+ , LDR fmt reg_dst addr_reg+ , instr+ , STC fmt reg_dst addr_reg+ , BCC NE lbl_retry (Just False)+ , ISYNC+ ]+ where+ getAmodeIndex (CmmMachOp (MO_Add _) [x, y])+ = do+ (regX, codeX) <- getSomeReg x+ (regY, codeY) <- getSomeReg y+ return (Amode (AddrRegReg regX regY) (codeX `appOL` codeY))+ getAmodeIndex other+ = do+ (reg, code) <- getSomeReg other+ return (Amode (AddrRegReg r0 reg) code) -- NB: r0 is 0 here!+ getSomeRegOrImm op sign dst+ = case n of+ CmmLit (CmmInt i _) | Just imm <- makeImmediate width sign i+ -> return (op dst dst (RIImm imm), nilOL)+ _+ -> do+ (n_reg, n_code) <- getSomeReg n+ return (op dst dst (RIReg n_reg), n_code)++genCCall (PrimTarget (MO_AtomicRead width)) [dst] [addr]+ = do dflags <- getDynFlags+ let platform = targetPlatform dflags+ fmt = intFormat width+ reg_dst = getRegisterReg platform (CmmLocal dst)+ form = if widthInBits width == 64 then DS else D+ Amode addr_reg addr_code <- getAmode form addr+ lbl_end <- getBlockIdNat+ return $ addr_code `appOL` toOL [ HWSYNC+ , LD fmt reg_dst addr_reg+ , CMP fmt reg_dst (RIReg reg_dst)+ , BCC NE lbl_end (Just False)+ , BCC ALWAYS lbl_end Nothing+ -- See Note [Seemingly useless cmp and bne]+ , NEWBLOCK lbl_end+ , ISYNC+ ]++-- Note [Seemingly useless cmp and bne]+-- In Power ISA, Book II, Section 4.4.1, Instruction Synchronize Instruction+-- the second paragraph says that isync may complete before storage accesses+-- "associated" with a preceding instruction have been performed. The cmp+-- operation and the following bne introduce a data and control dependency+-- on the load instruction (See also Power ISA, Book II, Appendix B.2.3, Safe+-- Fetch).+-- This is also what gcc does.+++genCCall (PrimTarget (MO_AtomicWrite width)) [] [addr, val] = do+ code <- assignMem_IntCode (intFormat width) addr val+ return $ unitOL(HWSYNC) `appOL` code+ genCCall (PrimTarget (MO_Clz width)) [dst] [src] = do dflags <- getDynFlags let platform = targetPlatform dflags@@ -1109,17 +1206,17 @@ lbl3 <- getBlockIdNat let vr_hi = getHiVRegFromLo vr_lo cntlz = toOL [ CMPL II32 vr_hi (RIImm (ImmInt 0))- , BCC NE lbl2- , BCC ALWAYS lbl1+ , BCC NE lbl2 Nothing+ , BCC ALWAYS lbl1 Nothing , NEWBLOCK lbl1 , CNTLZ II32 reg_dst vr_lo , ADD reg_dst reg_dst (RIImm (ImmInt 32))- , BCC ALWAYS lbl3+ , BCC ALWAYS lbl3 Nothing , NEWBLOCK lbl2 , CNTLZ II32 reg_dst vr_hi- , BCC ALWAYS lbl3+ , BCC ALWAYS lbl3 Nothing , NEWBLOCK lbl3 ]@@ -1166,8 +1263,8 @@ cnttzlo <- cnttz format reg_dst vr_lo let vr_hi = getHiVRegFromLo vr_lo cnttz64 = toOL [ CMPL format vr_lo (RIImm (ImmInt 0))- , BCC NE lbl2- , BCC ALWAYS lbl1+ , BCC NE lbl2 Nothing+ , BCC ALWAYS lbl1 Nothing , NEWBLOCK lbl1 , ADD x' vr_hi (RIImm (ImmInt (-1)))@@ -1175,12 +1272,12 @@ , CNTLZ format r' x'' -- 32 + (32 - clz(x'')) , SUBFC reg_dst r' (RIImm (ImmInt 64))- , BCC ALWAYS lbl3+ , BCC ALWAYS lbl3 Nothing , NEWBLOCK lbl2 ] `appOL` cnttzlo `appOL`- toOL [ BCC ALWAYS lbl3+ toOL [ BCC ALWAYS lbl3 Nothing , NEWBLOCK lbl3 ]@@ -1314,21 +1411,21 @@ -- rhat = un32 - q1*vn1 , MULL fmt tmp q1 (RIReg vn1) , SUBF rhat tmp un32- , BCC ALWAYS again1+ , BCC ALWAYS again1 Nothing , NEWBLOCK again1 -- if (q1 >= b || q1*vn0 > b*rhat + un1) , CMPL fmt q1 (RIReg b)- , BCC GEU then1- , BCC ALWAYS no1+ , BCC GEU then1 Nothing+ , BCC ALWAYS no1 Nothing , NEWBLOCK no1 , MULL fmt tmp q1 (RIReg vn0) , SL fmt tmp1 rhat (RIImm (ImmInt half)) , ADD tmp1 tmp1 (RIReg un1) , CMPL fmt tmp (RIReg tmp1)- , BCC LEU endif1- , BCC ALWAYS then1+ , BCC LEU endif1 Nothing+ , BCC ALWAYS then1 Nothing , NEWBLOCK then1 -- q1 = q1 - 1@@ -1337,8 +1434,8 @@ , ADD rhat rhat (RIReg vn1) -- if (rhat < b) goto again1 , CMPL fmt rhat (RIReg b)- , BCC LTT again1- , BCC ALWAYS endif1+ , BCC LTT again1 Nothing+ , BCC ALWAYS endif1 Nothing , NEWBLOCK endif1 -- un21 = un32*b + un1 - q1*v@@ -1352,21 +1449,21 @@ -- rhat = un21- q0*vn1 , MULL fmt tmp q0 (RIReg vn1) , SUBF rhat tmp un21- , BCC ALWAYS again2+ , BCC ALWAYS again2 Nothing , NEWBLOCK again2 -- if (q0>b || q0*vn0 > b*rhat + un0) , CMPL fmt q0 (RIReg b)- , BCC GEU then2- , BCC ALWAYS no2+ , BCC GEU then2 Nothing+ , BCC ALWAYS no2 Nothing , NEWBLOCK no2 , MULL fmt tmp q0 (RIReg vn0) , SL fmt tmp1 rhat (RIImm (ImmInt half)) , ADD tmp1 tmp1 (RIReg un0) , CMPL fmt tmp (RIReg tmp1)- , BCC LEU endif2- , BCC ALWAYS then2+ , BCC LEU endif2 Nothing+ , BCC ALWAYS then2 Nothing , NEWBLOCK then2 -- q0 = q0 - 1@@ -1375,8 +1472,8 @@ , ADD rhat rhat (RIReg vn1) -- if (rhat<b) goto again2 , CMPL fmt rhat (RIReg b)- , BCC LTT again2- , BCC ALWAYS endif2+ , BCC LTT again2 Nothing+ , BCC ALWAYS endif2 Nothing , NEWBLOCK endif2 -- compute remainder@@ -1903,15 +2000,18 @@ MO_Memcpy _ -> (fsLit "memcpy", False) MO_Memset _ -> (fsLit "memset", False) MO_Memmove _ -> (fsLit "memmove", False)+ MO_Memcmp _ -> (fsLit "memcmp", False) MO_BSwap w -> (fsLit $ bSwapLabel w, False) MO_PopCnt w -> (fsLit $ popCntLabel w, False)- MO_Clz w -> (fsLit $ clzLabel w, False)- MO_Ctz w -> (fsLit $ ctzLabel w, False)- MO_AtomicRMW w amop -> (fsLit $ atomicRMWLabel w amop, False)+ MO_Pdep w -> (fsLit $ pdepLabel w, False)+ MO_Pext w -> (fsLit $ pextLabel w, False)+ MO_Clz _ -> unsupported+ MO_Ctz _ -> unsupported+ MO_AtomicRMW {} -> unsupported MO_Cmpxchg w -> (fsLit $ cmpxchgLabel w, False)- MO_AtomicRead w -> (fsLit $ atomicReadLabel w, False)- MO_AtomicWrite w -> (fsLit $ atomicWriteLabel w, False)+ MO_AtomicRead _ -> unsupported+ MO_AtomicWrite _ -> unsupported MO_S_QuotRem {} -> unsupported MO_U_QuotRem {} -> unsupported@@ -1923,7 +2023,7 @@ MO_U_Mul2 {} -> unsupported MO_WriteBarrier -> unsupported MO_Touch -> unsupported- (MO_Prefetch_Data _ ) -> unsupported+ MO_Prefetch_Data _ -> unsupported unsupported = panic ("outOfLineCmmOp: " ++ show mop ++ " not supported") @@ -1995,7 +2095,7 @@ = CmmStaticLit (CmmInt 0 (wordWidth dflags)) jumpTableEntryRel (Just blockid) = CmmStaticLit (CmmLabelDiffOff blockLabel lbl 0)- where blockLabel = mkAsmTempLabel (getUnique blockid)+ where blockLabel = blockLbl blockid in Just (CmmData (Section ReadOnlyData lbl) (Statics lbl jumpTable)) generateJumpTableForInstr _ _ = Nothing
nativeGen/PPC/Cond.hs view
@@ -8,6 +8,8 @@ where +import GhcPrelude+ import Panic data Cond
nativeGen/PPC/Instr.hs view
@@ -23,6 +23,8 @@ where +import GhcPrelude+ import PPC.Regs import PPC.Cond import Instruction@@ -33,7 +35,8 @@ import CodeGen.Platform import BlockId-import Hoopl+import Hoopl.Collections+import Hoopl.Label import DynFlags import Cmm import CmmInfo@@ -123,7 +126,7 @@ insert_stack_insns (BasicBlock id insns) | Just new_blockid <- mapLookup id new_blockmap- = [ BasicBlock id [alloc, BCC ALWAYS new_blockid]+ = [ BasicBlock id [alloc, BCC ALWAYS new_blockid Nothing] , BasicBlock new_blockid block' ] | otherwise@@ -139,8 +142,8 @@ JMP _ -> dealloc : insn : r BCTR [] Nothing -> dealloc : insn : r BCTR ids label -> BCTR (map (fmap retarget) ids) label : r- BCCFAR cond b -> BCCFAR cond (retarget b) : r- BCC cond b -> BCC cond (retarget b) : r+ BCCFAR cond b p -> BCCFAR cond (retarget b) p : r+ BCC cond b p -> BCC cond (retarget b) p : r _ -> insn : r -- BL and BCTRL are call-like instructions rather than -- jumps, and are used only for C calls.@@ -189,10 +192,12 @@ -- Loads and stores. | LD Format Reg AddrMode -- Load format, dst, src | LDFAR Format Reg AddrMode -- Load format, dst, src 32 bit offset+ | LDR Format Reg AddrMode -- Load and reserve format, dst, src | LA Format Reg AddrMode -- Load arithmetic format, dst, src | ST Format Reg AddrMode -- Store format, src, dst | STFAR Format Reg AddrMode -- Store format, src, dst 32 bit offset | STU Format Reg AddrMode -- Store with Update format, src, dst+ | STC Format Reg AddrMode -- Store conditional format, src, dst | LIS Reg Imm -- Load Immediate Shifted dst, src | LI Reg Imm -- Load Immediate dst, src | MR Reg Reg -- Move Register dst, src -- also for fmr@@ -200,8 +205,12 @@ | CMP Format Reg RI -- format, src1, src2 | CMPL Format Reg RI -- format, src1, src2 - | BCC Cond BlockId- | BCCFAR Cond BlockId+ | BCC Cond BlockId (Maybe Bool) -- cond, block, hint+ | BCCFAR Cond BlockId (Maybe Bool) -- cond, block, hint+ -- hint:+ -- Just True: branch likely taken+ -- Just False: branch likely not taken+ -- Nothing: no hint | JMP CLabel -- same as branch, -- but with CLabel instead of block ID | MTCTR Reg@@ -231,6 +240,7 @@ | DIV Format Bool Reg Reg Reg | AND Reg Reg RI -- dst, src1, src2 | ANDC Reg Reg Reg -- AND with complement, dst = src1 & ~ src2+ | NAND Reg Reg Reg -- dst, src1, src2 | OR Reg Reg RI -- dst, src1, src2 | ORIS Reg Reg Imm -- OR Immediate Shifted dst, src1, src2 | XOR Reg Reg RI -- dst, src1, src2@@ -271,6 +281,8 @@ | MFLR Reg -- move from link register | FETCHPC Reg -- pseudo-instruction: -- bcl to next insn, mflr reg+ | HWSYNC -- heavy weight sync+ | ISYNC -- instruction synchronize | LWSYNC -- memory barrier | NOP -- no operation, PowerPC 64 bit -- needs this as place holder to@@ -289,17 +301,19 @@ = case instr of LD _ reg addr -> usage (regAddr addr, [reg]) LDFAR _ reg addr -> usage (regAddr addr, [reg])+ LDR _ reg addr -> usage (regAddr addr, [reg]) LA _ reg addr -> usage (regAddr addr, [reg]) ST _ reg addr -> usage (reg : regAddr addr, []) STFAR _ reg addr -> usage (reg : regAddr addr, []) STU _ reg addr -> usage (reg : regAddr addr, [])+ STC _ reg addr -> usage (reg : regAddr addr, []) LIS reg _ -> usage ([], [reg]) LI reg _ -> usage ([], [reg]) MR reg1 reg2 -> usage ([reg2], [reg1]) CMP _ reg ri -> usage (reg : regRI ri,[]) CMPL _ reg ri -> usage (reg : regRI ri,[])- BCC _ _ -> noUsage- BCCFAR _ _ -> noUsage+ BCC _ _ _ -> noUsage+ BCCFAR _ _ _ -> noUsage MTCTR reg -> usage ([reg],[]) BCTR _ _ -> noUsage BL _ params -> usage (params, callClobberedRegs platform)@@ -324,6 +338,7 @@ AND reg1 reg2 ri -> usage (reg2 : regRI ri, [reg1]) ANDC reg1 reg2 reg3 -> usage ([reg2,reg3], [reg1])+ NAND reg1 reg2 reg3 -> usage ([reg2,reg3], [reg1]) OR reg1 reg2 ri -> usage (reg2 : regRI ri, [reg1]) ORIS reg1 reg2 _ -> usage ([reg2], [reg1]) XOR reg1 reg2 ri -> usage (reg2 : regRI ri, [reg1])@@ -379,17 +394,19 @@ = case instr of LD fmt reg addr -> LD fmt (env reg) (fixAddr addr) LDFAR fmt reg addr -> LDFAR fmt (env reg) (fixAddr addr)+ LDR fmt reg addr -> LDR fmt (env reg) (fixAddr addr) LA fmt reg addr -> LA fmt (env reg) (fixAddr addr) ST fmt reg addr -> ST fmt (env reg) (fixAddr addr) STFAR fmt reg addr -> STFAR fmt (env reg) (fixAddr addr) STU fmt reg addr -> STU fmt (env reg) (fixAddr addr)+ STC fmt reg addr -> STC fmt (env reg) (fixAddr addr) LIS reg imm -> LIS (env reg) imm LI reg imm -> LI (env reg) imm MR reg1 reg2 -> MR (env reg1) (env reg2) CMP fmt reg ri -> CMP fmt (env reg) (fixRI ri) CMPL fmt reg ri -> CMPL fmt (env reg) (fixRI ri)- BCC cond lbl -> BCC cond lbl- BCCFAR cond lbl -> BCCFAR cond lbl+ BCC cond lbl p -> BCC cond lbl p+ BCCFAR cond lbl p -> BCCFAR cond lbl p MTCTR reg -> MTCTR (env reg) BCTR targets lbl -> BCTR targets lbl BL imm argRegs -> BL imm argRegs -- argument regs@@ -416,6 +433,7 @@ AND reg1 reg2 ri -> AND (env reg1) (env reg2) (fixRI ri) ANDC reg1 reg2 reg3 -> ANDC (env reg1) (env reg2) (env reg3)+ NAND reg1 reg2 reg3 -> NAND (env reg1) (env reg2) (env reg3) OR reg1 reg2 ri -> OR (env reg1) (env reg2) (fixRI ri) ORIS reg1 reg2 imm -> ORIS (env reg1) (env reg2) imm XOR reg1 reg2 ri -> XOR (env reg1) (env reg2) (fixRI ri)@@ -479,8 +497,8 @@ ppc_jumpDestsOfInstr :: Instr -> [BlockId] ppc_jumpDestsOfInstr insn = case insn of- BCC _ id -> [id]- BCCFAR _ id -> [id]+ BCC _ id _ -> [id]+ BCCFAR _ id _ -> [id] BCTR targets _ -> [id | Just id <- targets] _ -> [] @@ -491,8 +509,8 @@ ppc_patchJumpInstr :: Instr -> (BlockId -> BlockId) -> Instr ppc_patchJumpInstr insn patchF = case insn of- BCC cc id -> BCC cc (patchF id)- BCCFAR cc id -> BCCFAR cc (patchF id)+ BCC cc id p -> BCC cc (patchF id) p+ BCCFAR cc id p -> BCCFAR cc (patchF id) p BCTR ids lbl -> BCTR (map (fmap patchF) ids) lbl _ -> insn @@ -630,16 +648,12 @@ -- | Make an unconditional jump instruction.--- For architectures with branch delay slots, its ok to put--- a NOP after the jump. Don't fill the delay slot with an--- instruction that references regs or you'll confuse the--- linear allocator. ppc_mkJumpInstr :: BlockId -> [Instr] ppc_mkJumpInstr id- = [BCC ALWAYS id]+ = [BCC ALWAYS id Nothing] -- | Take the source and destination from this reg -> reg move instruction@@ -668,12 +682,12 @@ handleBlock addr (BasicBlock id instrs) = BasicBlock id (zipWith makeFar [addr..] instrs) - makeFar _ (BCC ALWAYS tgt) = BCC ALWAYS tgt- makeFar addr (BCC cond tgt)+ makeFar _ (BCC ALWAYS tgt _) = BCC ALWAYS tgt Nothing+ makeFar addr (BCC cond tgt p) | abs (addr - targetAddr) >= nearLimit- = BCCFAR cond tgt+ = BCCFAR cond tgt p | otherwise- = BCC cond tgt+ = BCC cond tgt p where Just targetAddr = lookupUFM blockAddressMap tgt makeFar _ other = other
nativeGen/PPC/Ppr.hs view
@@ -9,6 +9,8 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module PPC.Ppr (pprNatCmmDecl) where +import GhcPrelude+ import PPC.Regs import PPC.Instr import PPC.Cond@@ -20,11 +22,13 @@ import TargetReg import Cmm hiding (topInfoTable)-import Hoopl+import Hoopl.Collections+import Hoopl.Label +import BlockId import CLabel -import Unique ( pprUniqueAlways, Uniquable(..) )+import Unique ( pprUniqueAlways, getUnique ) import Platform import FastString import Outputable@@ -77,19 +81,17 @@ pprFunctionDescriptor :: CLabel -> SDoc pprFunctionDescriptor lab = pprGloblDecl lab- $$ text ".section \".opd\",\"aw\""- $$ text ".align 3"+ $$ text "\t.section \".opd\", \"aw\""+ $$ text "\t.align 3" $$ ppr lab <> char ':'- $$ text ".quad ."- <> ppr lab- <> text ",.TOC.@tocbase,0"- $$ text ".previous"- $$ text ".type "- <> ppr lab- <> text ", @function"- $$ char '.'- <> ppr lab- <> char ':'+ $$ text "\t.quad ."+ <> ppr lab+ <> text ",.TOC.@tocbase,0"+ $$ text "\t.previous"+ $$ text "\t.type"+ <+> ppr lab+ <> text ", @function"+ $$ char '.' <> ppr lab <> char ':' pprFunctionPrologue :: CLabel ->SDoc pprFunctionPrologue lab = pprGloblDecl lab@@ -107,7 +109,7 @@ pprBasicBlock :: LabelMap CmmStatics -> NatBasicBlock Instr -> SDoc pprBasicBlock info_env (BasicBlock blockid instrs) = maybe_infotable $$- pprLabel (mkAsmTempLabel (getUnique blockid)) $$+ pprLabel (blockLbl blockid) $$ vcat (map pprInstr instrs) where maybe_infotable = case mapLookup blockid info_env of@@ -309,11 +311,13 @@ pprAddr :: AddrMode -> SDoc pprAddr (AddrRegReg r1 r2)- = pprReg r1 <+> text ", " <+> pprReg r2--pprAddr (AddrRegImm r1 (ImmInt i)) = hcat [ int i, char '(', pprReg r1, char ')' ]-pprAddr (AddrRegImm r1 (ImmInteger i)) = hcat [ integer i, char '(', pprReg r1, char ')' ]-pprAddr (AddrRegImm r1 imm) = hcat [ pprImm imm, char '(', pprReg r1, char ')' ]+ = pprReg r1 <> char ',' <+> pprReg r2+pprAddr (AddrRegImm r1 (ImmInt i))+ = hcat [ int i, char '(', pprReg r1, char ')' ]+pprAddr (AddrRegImm r1 (ImmInteger i))+ = hcat [ integer i, char '(', pprReg r1, char ')' ]+pprAddr (AddrRegImm r1 imm)+ = hcat [ pprImm imm, char '(', pprReg r1, char ')' ] pprSectionAlign :: Section -> SDoc@@ -449,15 +453,27 @@ text ", ", pprAddr addr ]+ pprInstr (LDFAR fmt reg (AddrRegImm source off)) = sdocWithPlatform $ \platform -> vcat [ pprInstr (ADDIS (tmpReg platform) source (HA off)), pprInstr (LD fmt reg (AddrRegImm (tmpReg platform) (LO off))) ]- pprInstr (LDFAR _ _ _) = panic "PPC.Ppr.pprInstr LDFAR: no match" +pprInstr (LDR fmt reg1 addr) = hcat [+ text "\tl",+ case fmt of+ II32 -> char 'w'+ II64 -> char 'd'+ _ -> panic "PPC.Ppr.Instr LDR: no match",+ text "arx\t",+ pprReg reg1,+ text ", ",+ pprAddr addr+ ]+ pprInstr (LA fmt reg addr) = hcat [ char '\t', text "l",@@ -507,6 +523,17 @@ text ", ", pprAddr addr ]+pprInstr (STC fmt reg1 addr) = hcat [+ text "\tst",+ case fmt of+ II32 -> char 'w'+ II64 -> char 'd'+ _ -> panic "PPC.Ppr.Instr STC: no match",+ text "cx.\t",+ pprReg reg1,+ text ", ",+ pprAddr addr+ ] pprInstr (LIS reg imm) = hcat [ char '\t', text "lis",@@ -568,19 +595,25 @@ RIReg _ -> empty RIImm _ -> char 'i' ]-pprInstr (BCC cond blockid) = hcat [+pprInstr (BCC cond blockid prediction) = hcat [ char '\t', text "b", pprCond cond,+ pprPrediction prediction, char '\t', ppr lbl ]- where lbl = mkAsmTempLabel (getUnique blockid)+ where lbl = mkLocalBlockLabel (getUnique blockid)+ pprPrediction p = case p of+ Nothing -> empty+ Just True -> char '+'+ Just False -> char '-' -pprInstr (BCCFAR cond blockid) = vcat [+pprInstr (BCCFAR cond blockid prediction) = vcat [ hcat [ text "\tb", pprCond (condNegate cond),+ neg_prediction, text "\t$+8" ], hcat [@@ -588,7 +621,11 @@ ppr lbl ] ]- where lbl = mkAsmTempLabel (getUnique blockid)+ where lbl = mkLocalBlockLabel (getUnique blockid)+ neg_prediction = case prediction of+ Nothing -> empty+ Just True -> char '-'+ Just False -> char '+' pprInstr (JMP lbl) -- We never jump to ForeignLabels; if we ever do, c.f. handling for "BL"@@ -740,6 +777,7 @@ ] pprInstr (AND reg1 reg2 ri) = pprLogic (sLit "and") reg1 reg2 ri pprInstr (ANDC reg1 reg2 reg3) = pprLogic (sLit "andc") reg1 reg2 (RIReg reg3)+pprInstr (NAND reg1 reg2 reg3) = pprLogic (sLit "nand") reg1 reg2 (RIReg reg3) pprInstr (OR reg1 reg2 ri) = pprLogic (sLit "or") reg1 reg2 ri pprInstr (XOR reg1 reg2 ri) = pprLogic (sLit "xor") reg1 reg2 ri@@ -920,6 +958,10 @@ text "\tbcl\t20,31,1f", hcat [ text "1:\tmflr\t", pprReg reg ] ]++pprInstr HWSYNC = text "\tsync"++pprInstr ISYNC = text "\tisync" pprInstr LWSYNC = text "\tlwsync"
nativeGen/PPC/RegInfo.hs view
@@ -20,6 +20,8 @@ #include "nativeGen/NCG.h" #include "HsVersions.h" +import GhcPrelude+ import PPC.Instr import BlockId@@ -49,8 +51,8 @@ shortcutLabel :: (BlockId -> Maybe JumpDest) -> CLabel -> CLabel shortcutLabel fn lab- | Just uq <- maybeAsmTemp lab = shortBlockId fn (mkBlockId uq)- | otherwise = lab+ | Just blkId <- maybeLocalBlockLabel lab = shortBlockId fn blkId+ | otherwise = lab shortcutStatic :: (BlockId -> Maybe JumpDest) -> CmmStatic -> CmmStatic shortcutStatic fn (CmmStaticLit (CmmLabel lab))@@ -69,6 +71,6 @@ shortBlockId fn blockid = case fn blockid of- Nothing -> mkAsmTempLabel uq+ Nothing -> mkLocalBlockLabel uq Just (DestBlockId blockid') -> shortBlockId fn blockid' where uq = getUnique blockid
nativeGen/PPC/Regs.hs view
@@ -50,6 +50,8 @@ #include "nativeGen/NCG.h" #include "HsVersions.h" +import GhcPrelude+ import Reg import RegClass import Format@@ -70,7 +72,7 @@ -- squeese functions for the graph allocator ----------------------------------- -- | regSqueeze_class reg--- Calculuate the maximum number of register colors that could be+-- Calculate the maximum number of register colors that could be -- denied to a node of this class due to having this reg -- as a neighbour. --
nativeGen/PprBase.hs view
@@ -16,6 +16,9 @@ where +import GhcPrelude++import AsmUtils import CLabel import Cmm import DynFlags@@ -93,14 +96,15 @@ pprSectionHeader :: Platform -> Section -> SDoc pprSectionHeader platform (Section t suffix) = case platformOS platform of- OSAIX -> pprXcoffSectionHeader t- OSDarwin -> pprDarwinSectionHeader t- _ -> pprGNUSectionHeader t suffix+ OSAIX -> pprXcoffSectionHeader t+ OSDarwin -> pprDarwinSectionHeader t+ OSMinGW32 -> pprGNUSectionHeader (char '$') t suffix+ _ -> pprGNUSectionHeader (char '.') t suffix -pprGNUSectionHeader :: SectionType -> CLabel -> SDoc-pprGNUSectionHeader t suffix = sdocWithDynFlags $ \dflags ->+pprGNUSectionHeader :: SDoc -> SectionType -> CLabel -> SDoc+pprGNUSectionHeader sep t suffix = sdocWithDynFlags $ \dflags -> let splitSections = gopt Opt_SplitSections dflags- subsection | splitSections = char '.' <> ppr suffix+ subsection | splitSections = sep <> ppr suffix | otherwise = empty in text ".section " <> ptext (header dflags) <> subsection <> flags dflags@@ -108,21 +112,29 @@ header dflags = case t of Text -> sLit ".text" Data -> sLit ".data"- ReadOnlyData -> sLit ".rodata"- RelocatableReadOnlyData -> sLit ".data.rel.ro"+ ReadOnlyData | OSMinGW32 <- platformOS (targetPlatform dflags)+ -> sLit ".rdata"+ | otherwise -> sLit ".rodata"+ RelocatableReadOnlyData | OSMinGW32 <- platformOS (targetPlatform dflags)+ -- Concept does not exist on Windows,+ -- So map these to R/O data.+ -> sLit ".rdata$rel.ro"+ | otherwise -> sLit ".data.rel.ro" UninitialisedData -> sLit ".bss"- ReadOnlyData16 -> sLit ".rodata.cst16"+ ReadOnlyData16 | OSMinGW32 <- platformOS (targetPlatform dflags)+ -> sLit ".rdata$cst16"+ | otherwise -> sLit ".rodata.cst16" CString | OSMinGW32 <- platformOS (targetPlatform dflags)- -> sLit ".rdata"+ -> sLit ".rdata" | otherwise -> sLit ".rodata.str" OtherSection _ -> panic "PprBase.pprGNUSectionHeader: unknown section type" flags dflags = case t of CString | OSMinGW32 <- platformOS (targetPlatform dflags)- -> text ",\"dr\""- | otherwise -> text ",\"aMS\",@progbits,1"+ -> empty+ | otherwise -> text ",\"aMS\"," <> sectionType "progbits" <> text ",1" _ -> empty -- XCOFF doesn't support relocating label-differences, so we place all
nativeGen/Reg.hs view
@@ -26,6 +26,8 @@ where +import GhcPrelude+ import Outputable import Unique import RegClass
nativeGen/RegAlloc/Graph/ArchBase.hs view
@@ -21,13 +21,15 @@ bound, squeese ) where+import GhcPrelude+ import UniqSet import UniqFM import Unique -- Some basic register classes.--- These aren't nessesarally in 1-to-1 correspondance with the allocatable+-- These aren't necessarily in 1-to-1 correspondence with the allocatable -- RegClasses in MachRegs.hs data RegClass -- general purpose regs
nativeGen/RegAlloc/Graph/ArchX86.hs view
@@ -14,10 +14,15 @@ worst, squeese, ) where++import GhcPrelude+ import RegAlloc.Graph.ArchBase (Reg(..), RegSub(..), RegClass(..)) import UniqSet +import qualified Data.Array as A + -- | Determine the class of a register classOfReg :: Reg -> RegClass classOfReg reg@@ -57,18 +62,28 @@ regName reg = case reg of Reg ClassG32 i- | i <= 7-> Just $ [ "eax", "ebx", "ecx", "edx"- , "ebp", "esi", "edi", "esp" ] !! i+ | i <= 7 ->+ let names = A.listArray (0,8)+ [ "eax", "ebx", "ecx", "edx"+ , "ebp", "esi", "edi", "esp" ]+ in Just $ names A.! i RegSub SubL16 (Reg ClassG32 i)- | i <= 7 -> Just $ [ "ax", "bx", "cx", "dx"- , "bp", "si", "di", "sp"] !! i+ | i <= 7 ->+ let names = A.listArray (0,8)+ [ "ax", "bx", "cx", "dx"+ , "bp", "si", "di", "sp"]+ in Just $ names A.! i RegSub SubL8 (Reg ClassG32 i)- | i <= 3 -> Just $ [ "al", "bl", "cl", "dl"] !! i+ | i <= 3 ->+ let names = A.listArray (0,4) [ "al", "bl", "cl", "dl"]+ in Just $ names A.! i RegSub SubL8H (Reg ClassG32 i)- | i <= 3 -> Just $ [ "ah", "bh", "ch", "dh"] !! i+ | i <= 3 ->+ let names = A.listArray (0,4) [ "ah", "bh", "ch", "dh"]+ in Just $ names A.! i _ -> Nothing
nativeGen/RegAlloc/Graph/Coalesce.hs view
@@ -3,6 +3,8 @@ regCoalesce, slurpJoinMovs ) where+import GhcPrelude+ import RegAlloc.Liveness import Instruction import Reg@@ -62,7 +64,7 @@ -- | Slurp out mov instructions that only serve to join live ranges. ----- During a mov, if the source reg dies and the destiation reg is+-- During a mov, if the source reg dies and the destination reg is -- born then we can rename the two regs to the same thing and -- eliminate the move. slurpJoinMovs
nativeGen/RegAlloc/Graph/Main.hs view
@@ -4,6 +4,8 @@ module RegAlloc.Graph.Main ( regAlloc ) where+import GhcPrelude+ import qualified GraphColor as Color import RegAlloc.Liveness import RegAlloc.Graph.Spill
nativeGen/RegAlloc/Graph/Spill.hs view
@@ -7,12 +7,14 @@ SpillStats(..), accSpillSL ) where+import GhcPrelude+ import RegAlloc.Liveness import Instruction import Reg import Cmm hiding (RegSet) import BlockId-import Hoopl+import Hoopl.Collections import MonadUtils import State@@ -34,7 +36,7 @@ -- TODO: See if we can split some of the live ranges instead of just globally -- spilling the virtual reg. This might make the spill cleaner's job easier. ----- TODO: On CISCy x86 and x86_64 we don't nessesarally have to add a mov instruction+-- TODO: On CISCy x86 and x86_64 we don't necessarily have to add a mov instruction -- when making spills. If an instr is using a spilled virtual we may be able to -- address the spill slot directly. --
nativeGen/RegAlloc/Graph/SpillClean.hs view
@@ -28,12 +28,13 @@ module RegAlloc.Graph.SpillClean ( cleanSpills ) where+import GhcPrelude+ import RegAlloc.Liveness import Instruction import Reg import BlockId-import Hoopl import Cmm import UniqSet import UniqFM@@ -41,6 +42,7 @@ import State import Outputable import Platform+import Hoopl.Collections import Data.List import Data.Maybe
nativeGen/RegAlloc/Graph/SpillCost.hs view
@@ -13,6 +13,8 @@ lifeMapFromSpillCostInfo ) where+import GhcPrelude+ import RegAlloc.Liveness import Instruction import RegClass@@ -20,7 +22,7 @@ import GraphBase -import Hoopl (mapLookup)+import Hoopl.Collections (mapLookup) import Cmm import UniqFM import UniqSet@@ -165,7 +167,7 @@ -- cost = sum loadCost * freq (u) + sum storeCost * freq (d) -- u <- uses (v) d <- defs (v) ----- There are no loops in our code at the momemnt, so we can set the freq's to 1.+-- There are no loops in our code at the moment, so we can set the freq's to 1. -- -- If we don't have live range splitting then Chaitins function performs badly -- if we have lots of nested live ranges and very few registers.
nativeGen/RegAlloc/Graph/Stats.hs view
@@ -16,6 +16,8 @@ #include "nativeGen/NCG.h" +import GhcPrelude+ import qualified GraphColor as Color import RegAlloc.Liveness import RegAlloc.Graph.Spill
nativeGen/RegAlloc/Graph/TrivColorable.hs view
@@ -8,6 +8,8 @@ #include "HsVersions.h" +import GhcPrelude+ import RegClass import Reg
nativeGen/RegAlloc/Linear/Base.hs view
@@ -17,6 +17,8 @@ where +import GhcPrelude+ import RegAlloc.Linear.StackMap import RegAlloc.Liveness import Reg
nativeGen/RegAlloc/Linear/FreeRegs.hs view
@@ -9,6 +9,8 @@ where +import GhcPrelude+ import Reg import RegClass
nativeGen/RegAlloc/Linear/JoinToTargets.hs view
@@ -9,6 +9,8 @@ -- module RegAlloc.Linear.JoinToTargets (joinToTargets) where +import GhcPrelude+ import RegAlloc.Linear.State import RegAlloc.Linear.Base import RegAlloc.Linear.FreeRegs@@ -17,7 +19,7 @@ import Reg import BlockId-import Hoopl+import Hoopl.Collections import Digraph import DynFlags import Outputable@@ -229,7 +231,7 @@ -- We cut some corners by not handling memory-to-memory moves. -- This shouldn't happen because every temporary gets its own stack slot. ---makeRegMovementGraph :: RegMap Loc -> RegMap Loc -> [(Unique, Loc, [Loc])]+makeRegMovementGraph :: RegMap Loc -> RegMap Loc -> [Node Loc Unique] makeRegMovementGraph adjusted_assig dest_assig = [ node | (vreg, src) <- nonDetUFMToList adjusted_assig -- This is non-deterministic but we do not@@ -255,15 +257,15 @@ :: a -> Loc -- ^ source of move -> Loc -- ^ destination of move- -> [(a, Loc, [Loc])]+ -> [Node Loc a ] expandNode vreg loc@(InReg src) (InBoth dst mem)- | src == dst = [(vreg, loc, [InMem mem])]- | otherwise = [(vreg, loc, [InReg dst, InMem mem])]+ | src == dst = [DigraphNode vreg loc [InMem mem]]+ | otherwise = [DigraphNode vreg loc [InReg dst, InMem mem]] expandNode vreg loc@(InMem src) (InBoth dst mem)- | src == mem = [(vreg, loc, [InReg dst])]- | otherwise = [(vreg, loc, [InReg dst, InMem mem])]+ | src == mem = [DigraphNode vreg loc [InReg dst]]+ | otherwise = [DigraphNode vreg loc [InReg dst, InMem mem]] expandNode _ (InBoth _ src) (InMem dst) | src == dst = [] -- guaranteed to be true@@ -276,7 +278,7 @@ expandNode vreg src dst | src == dst = []- | otherwise = [(vreg, src, [dst])]+ | otherwise = [DigraphNode vreg src [dst]] -- | Generate fixup code for a particular component in the move graph@@ -286,14 +288,14 @@ -- handleComponent :: Instruction instr- => Int -> instr -> SCC (Unique, Loc, [Loc])+ => Int -> instr -> SCC (Node Loc Unique) -> RegM freeRegs [instr] -- If the graph is acyclic then we won't get the swapping problem below. -- In this case we can just do the moves directly, and avoid having to -- go via a spill slot. ---handleComponent delta _ (AcyclicSCC (vreg, src, dsts))+handleComponent delta _ (AcyclicSCC (DigraphNode vreg src dsts)) = mapM (makeMove delta vreg src) dsts @@ -313,7 +315,7 @@ -- require a fixup. -- handleComponent delta instr- (CyclicSCC ((vreg, InReg sreg, (InReg dreg: _)) : rest))+ (CyclicSCC ((DigraphNode vreg (InReg sreg) ((InReg dreg: _))) : rest)) -- dest list may have more than one element, if the reg is also InMem. = do -- spill the source into its slot
nativeGen/RegAlloc/Linear/Main.hs view
@@ -102,6 +102,8 @@ #include "HsVersions.h" +import GhcPrelude+ import RegAlloc.Linear.State import RegAlloc.Linear.Base import RegAlloc.Linear.StackMap@@ -118,7 +120,7 @@ import Reg import BlockId-import Hoopl+import Hoopl.Collections import Cmm hiding (RegSet) import Digraph@@ -496,7 +498,7 @@ -- debugging {- freeregs <- getFreeRegsR assig <- getAssigR- pprDebugAndThen (defaultDynFlags Settings{ sTargetPlatform=platform }) trace "genRaInsn"+ pprDebugAndThen (defaultDynFlags Settings{ sTargetPlatform=platform } undefined) trace "genRaInsn" (ppr instr $$ text "r_dying = " <+> ppr r_dying $$ text "w_dying = " <+> ppr w_dying@@ -807,27 +809,29 @@ -- case (3): we need to push something out to free up a register [] ->- do let keep' = map getUnique keep+ do let inRegOrBoth (InReg _) = True+ inRegOrBoth (InBoth _ _) = True+ inRegOrBoth _ = False+ let candidates' =+ flip delListFromUFM keep $+ filterUFM inRegOrBoth $+ assig+ -- This is non-deterministic but we do not+ -- currently support deterministic code-generation.+ -- See Note [Unique Determinism and code generation]+ let candidates = nonDetUFMToList candidates' -- the vregs we could kick out that are already in a slot let candidates_inBoth = [ (temp, reg, mem)- | (temp, InBoth reg mem) <- nonDetUFMToList assig- -- This is non-deterministic but we do not- -- currently support deterministic code-generation.- -- See Note [Unique Determinism and code generation]- , temp `notElem` keep'+ | (temp, InBoth reg mem) <- candidates , targetClassOfRealReg platform reg == classOfVirtualReg r ] -- the vregs we could kick out that are only in a reg -- this would require writing the reg to a new slot before using it. let candidates_inReg = [ (temp, reg)- | (temp, InReg reg) <- nonDetUFMToList assig- -- This is non-deterministic but we do not- -- currently support deterministic code-generation.- -- See Note [Unique Determinism and code generation]- , temp `notElem` keep'+ | (temp, InReg reg) <- candidates , targetClassOfRealReg platform reg == classOfVirtualReg r ] let result
nativeGen/RegAlloc/Linear/PPC/FreeRegs.hs view
@@ -2,6 +2,8 @@ module RegAlloc.Linear.PPC.FreeRegs where +import GhcPrelude+ import PPC.Regs import RegClass import Reg
nativeGen/RegAlloc/Linear/SPARC/FreeRegs.hs view
@@ -3,6 +3,8 @@ module RegAlloc.Linear.SPARC.FreeRegs where +import GhcPrelude+ import SPARC.Regs import RegClass import Reg
nativeGen/RegAlloc/Linear/StackMap.hs view
@@ -20,6 +20,8 @@ where +import GhcPrelude+ import DynFlags import UniqFM import Unique
nativeGen/RegAlloc/Linear/State.hs view
@@ -31,6 +31,8 @@ ) where +import GhcPrelude+ import RegAlloc.Linear.Stats import RegAlloc.Linear.StackMap import RegAlloc.Linear.Base
nativeGen/RegAlloc/Linear/Stats.hs view
@@ -6,6 +6,8 @@ where +import GhcPrelude+ import RegAlloc.Linear.Base import RegAlloc.Liveness import Instruction
nativeGen/RegAlloc/Linear/X86/FreeRegs.hs view
@@ -3,6 +3,8 @@ module RegAlloc.Linear.X86.FreeRegs where +import GhcPrelude+ import X86.Regs import RegClass import Reg
nativeGen/RegAlloc/Linear/X86_64/FreeRegs.hs view
@@ -3,6 +3,8 @@ module RegAlloc.Linear.X86_64.FreeRegs where +import GhcPrelude+ import X86.Regs import RegClass import Reg
nativeGen/RegAlloc/Liveness.hs view
@@ -35,11 +35,14 @@ regLiveness, natCmmTopToLive ) where+import GhcPrelude+ import Reg import Instruction import BlockId-import Hoopl+import Hoopl.Collections+import Hoopl.Label import Cmm hiding (RegSet, emptyRegSet) import PprCmm() @@ -677,29 +680,28 @@ -- exactly what we do. (#7574) -- sccBlocks- :: Instruction instr+ :: forall instr . Instruction instr => [NatBasicBlock instr] -> [BlockId] -> [SCC (NatBasicBlock instr)] -sccBlocks blocks entries = map (fmap get_node) sccs+sccBlocks blocks entries = map (fmap node_payload) sccs where- -- nodes :: [(NatBasicBlock instr, Unique, [Unique])]- nodes = [ (block, id, getOutEdges instrs)+ nodes :: [ Node BlockId (NatBasicBlock instr) ]+ nodes = [ DigraphNode block id (getOutEdges instrs) | block@(BasicBlock id instrs) <- blocks ] g1 = graphFromEdgedVerticesUniq nodes reachable :: LabelSet- reachable = setFromList [ id | (_,id,_) <- reachablesG g1 roots ]+ reachable = setFromList [ node_key node | node <- reachablesG g1 roots ] - g2 = graphFromEdgedVerticesUniq [ node | node@(_,id,_) <- nodes- , id `setMember` reachable ]+ g2 = graphFromEdgedVerticesUniq [ node | node <- nodes+ , node_key node+ `setMember` reachable ] sccs = stronglyConnCompG g2 - get_node (n, _, _) = n- getOutEdges :: Instruction instr => [instr] -> [BlockId] getOutEdges instrs = concat $ map jumpDestsOfInstr instrs @@ -709,7 +711,8 @@ -- node: (NatBasicBlock, BlockId, [BlockId]). This takes -- advantage of the fact that Digraph only looks at the key, -- even though it asks for the whole triple.- roots = [(panic "sccBlocks",b,panic "sccBlocks") | b <- entries ]+ roots = [DigraphNode (panic "sccBlocks") b (panic "sccBlocks")+ | b <- entries ] @@ -811,7 +814,7 @@ computeLiveness platform sccs = case checkIsReverseDependent sccs of Nothing -> livenessSCCs platform mapEmpty [] sccs- Just bad -> pprPanic "RegAlloc.Liveness.computeLivenss"+ Just bad -> pprPanic "RegAlloc.Liveness.computeLiveness" (vcat [ text "SCCs aren't in reverse dependent order" , text "bad blockId" <+> ppr bad , ppr sccs])
nativeGen/RegClass.hs view
@@ -4,6 +4,8 @@ where +import GhcPrelude+ import Outputable import Unique
nativeGen/SPARC/AddrMode.hs view
@@ -6,6 +6,8 @@ where +import GhcPrelude+ import SPARC.Imm import SPARC.Base import Reg
nativeGen/SPARC/Base.hs view
@@ -18,6 +18,8 @@ where +import GhcPrelude+ import DynFlags import Panic
nativeGen/SPARC/CodeGen.hs view
@@ -22,6 +22,8 @@ #include "MachDeps.h" -- NCG stuff:+import GhcPrelude+ import SPARC.Base import SPARC.CodeGen.Sanity import SPARC.CodeGen.Amode@@ -44,7 +46,8 @@ import Cmm import CmmUtils import CmmSwitch-import Hoopl+import Hoopl.Block+import Hoopl.Graph import PIC import Reg import CLabel@@ -57,7 +60,6 @@ import OrdList import Outputable import Platform-import Unique import Control.Monad ( mapAndUnzipM ) @@ -161,7 +163,7 @@ {--Now, given a tree (the argument to an CmmLoad) that references memory,+Now, given a tree (the argument to a CmmLoad) that references memory, produce a suitable addressing mode. A Rule of the Game (tm) for Amodes: use of the addr bit must@@ -184,7 +186,7 @@ jumpTableEntry :: DynFlags -> Maybe BlockId -> CmmStatic jumpTableEntry dflags Nothing = CmmStaticLit (CmmInt 0 (wordWidth dflags)) jumpTableEntry _ (Just blockid) = CmmStaticLit (CmmLabel blockLabel)- where blockLabel = mkAsmTempLabel (getUnique blockid)+ where blockLabel = blockLbl blockid @@ -648,9 +650,12 @@ MO_Memcpy _ -> fsLit "memcpy" MO_Memset _ -> fsLit "memset" MO_Memmove _ -> fsLit "memmove"+ MO_Memcmp _ -> fsLit "memcmp" MO_BSwap w -> fsLit $ bSwapLabel w MO_PopCnt w -> fsLit $ popCntLabel w+ MO_Pdep w -> fsLit $ pdepLabel w+ MO_Pext w -> fsLit $ pextLabel w MO_Clz w -> fsLit $ clzLabel w MO_Ctz w -> fsLit $ ctzLabel w MO_AtomicRMW w amop -> fsLit $ atomicRMWLabel w amop
nativeGen/SPARC/CodeGen/Amode.hs view
@@ -4,6 +4,8 @@ where +import GhcPrelude+ import {-# SOURCE #-} SPARC.CodeGen.Gen32 import SPARC.CodeGen.Base import SPARC.AddrMode
nativeGen/SPARC/CodeGen/Base.hs view
@@ -13,6 +13,8 @@ where +import GhcPrelude+ import SPARC.Instr import SPARC.Cond import SPARC.AddrMode
nativeGen/SPARC/CodeGen/CondCode.hs view
@@ -6,6 +6,8 @@ where +import GhcPrelude+ import {-# SOURCE #-} SPARC.CodeGen.Gen32 import SPARC.CodeGen.Base import SPARC.Instr
nativeGen/SPARC/CodeGen/Expand.hs view
@@ -5,6 +5,8 @@ where +import GhcPrelude+ import SPARC.Instr import SPARC.Imm import SPARC.AddrMode
nativeGen/SPARC/CodeGen/Gen32.hs view
@@ -6,6 +6,8 @@ where +import GhcPrelude+ import SPARC.CodeGen.CondCode import SPARC.CodeGen.Amode import SPARC.CodeGen.Gen64
nativeGen/SPARC/CodeGen/Gen64.hs view
@@ -7,6 +7,8 @@ where +import GhcPrelude+ import {-# SOURCE #-} SPARC.CodeGen.Gen32 import SPARC.CodeGen.Base import SPARC.CodeGen.Amode
nativeGen/SPARC/CodeGen/Sanity.hs view
@@ -6,6 +6,8 @@ where +import GhcPrelude+ import SPARC.Instr import SPARC.Ppr () import Instruction
nativeGen/SPARC/Cond.hs view
@@ -7,6 +7,8 @@ where +import GhcPrelude+ -- | Branch condition codes. data Cond = ALWAYS
nativeGen/SPARC/Imm.hs view
@@ -7,6 +7,8 @@ where +import GhcPrelude+ import Cmm import CLabel
nativeGen/SPARC/Instr.hs view
@@ -25,6 +25,8 @@ where +import GhcPrelude+ import SPARC.Stack import SPARC.Imm import SPARC.AddrMode
nativeGen/SPARC/Ppr.hs view
@@ -25,6 +25,8 @@ #include "HsVersions.h" #include "nativeGen/NCG.h" +import GhcPrelude+ import SPARC.Regs import SPARC.Instr import SPARC.Cond@@ -38,10 +40,12 @@ import Cmm hiding (topInfoTable) import PprCmm()+import BlockId import CLabel-import Hoopl+import Hoopl.Label+import Hoopl.Collections -import Unique ( Uniquable(..), pprUniqueAlways )+import Unique ( pprUniqueAlways ) import Outputable import Platform import FastString@@ -90,7 +94,7 @@ pprBasicBlock :: LabelMap CmmStatics -> NatBasicBlock Instr -> SDoc pprBasicBlock info_env (BasicBlock blockid instrs) = maybe_infotable $$- pprLabel (mkAsmTempLabel (getUnique blockid)) $$+ pprLabel (blockLbl blockid) $$ vcat (map pprInstr instrs) where maybe_infotable = case mapLookup blockid info_env of@@ -401,7 +405,7 @@ pprReg reg ] --- 64 bit FP storees are expanded into individual instructions in CodeGen.Expand+-- 64 bit FP stores are expanded into individual instructions in CodeGen.Expand pprInstr (ST FF64 reg _) | RegReal (RealRegSingle{}) <- reg = panic "SPARC.Ppr: not emitting potentially misaligned ST FF64 instr"@@ -540,7 +544,7 @@ text "\tb", pprCond cond, if b then pp_comma_a else empty, char '\t',- ppr (mkAsmTempLabel (getUnique blockid))+ ppr (blockLbl blockid) ] pprInstr (BF cond b blockid)@@ -548,7 +552,7 @@ text "\tfb", pprCond cond, if b then pp_comma_a else empty, char '\t',- ppr (mkAsmTempLabel (getUnique blockid))+ ppr (blockLbl blockid) ] pprInstr (JMP addr) = text "\tjmp\t" <> pprAddr addr
nativeGen/SPARC/Regs.hs view
@@ -32,6 +32,8 @@ where +import GhcPrelude+ import CodeGen.Platform.SPARC import Reg import RegClass@@ -75,7 +77,7 @@ -- | regSqueeze_class reg--- Calculuate the maximum number of register colors that could be+-- Calculate the maximum number of register colors that could be -- denied to a node of this class due to having this reg -- as a neighbour. --
nativeGen/SPARC/ShortcutJump.hs view
@@ -8,6 +8,8 @@ where +import GhcPrelude+ import SPARC.Instr import SPARC.Imm @@ -16,10 +18,8 @@ import Cmm import Panic-import Unique - data JumpDest = DestBlockId BlockId | DestImm Imm@@ -46,8 +46,8 @@ shortcutLabel :: (BlockId -> Maybe JumpDest) -> CLabel -> CLabel shortcutLabel fn lab- | Just uq <- maybeAsmTemp lab = shortBlockId fn (mkBlockId uq)- | otherwise = lab+ | Just blkId <- maybeLocalBlockLabel lab = shortBlockId fn blkId+ | otherwise = lab shortcutStatic :: (BlockId -> Maybe JumpDest) -> CmmStatic -> CmmStatic shortcutStatic fn (CmmStaticLit (CmmLabel lab))@@ -63,7 +63,7 @@ shortBlockId :: (BlockId -> Maybe JumpDest) -> BlockId -> CLabel shortBlockId fn blockid = case fn blockid of- Nothing -> mkAsmTempLabel (getUnique blockid)+ Nothing -> blockLbl blockid Just (DestBlockId blockid') -> shortBlockId fn blockid' Just (DestImm (ImmCLbl lbl)) -> lbl _other -> panic "shortBlockId"
nativeGen/SPARC/Stack.hs view
@@ -7,6 +7,8 @@ where +import GhcPrelude+ import SPARC.AddrMode import SPARC.Regs import SPARC.Base
nativeGen/TargetReg.hs view
@@ -21,6 +21,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Reg import RegClass import Format
nativeGen/X86/CodeGen.hs view
@@ -2,9 +2,7 @@ -- The default iteration limit is a bit too low for the definitions -- in this module.-#if __GLASGOW_HASKELL__ >= 800 {-# OPTIONS_GHC -fmax-pmcheck-iterations=10000000 #-}-#endif ----------------------------------------------------------------------------- --@@ -32,6 +30,8 @@ #include "MachDeps.h" -- NCG stuff:+import GhcPrelude+ import X86.Instr import X86.Cond import X86.Regs@@ -55,7 +55,8 @@ import CmmUtils import CmmSwitch import Cmm-import Hoopl+import Hoopl.Block+import Hoopl.Graph import CLabel import CoreSyn ( Tickish(..) ) import SrcLoc ( srcSpanFile, srcSpanStartLine, srcSpanStartCol )@@ -64,7 +65,6 @@ import ForeignCall ( CCallConv(..) ) import OrdList import Outputable-import Unique import FastString import DynFlags import Util@@ -294,7 +294,7 @@ = Amode AddrMode InstrBlock {--Now, given a tree (the argument to an CmmLoad) that references memory,+Now, given a tree (the argument to a CmmLoad) that references memory, produce a suitable addressing mode. A Rule of the Game (tm) for Amodes: use of the addr bit must@@ -327,7 +327,7 @@ jumpTableEntry :: DynFlags -> Maybe BlockId -> CmmStatic jumpTableEntry dflags Nothing = CmmStaticLit (CmmInt 0 (wordWidth dflags)) jumpTableEntry _ (Just blockid) = CmmStaticLit (CmmLabel blockLabel)- where blockLabel = mkAsmTempLabel (getUnique blockid)+ where blockLabel = blockLbl blockid -- -----------------------------------------------------------------------------@@ -502,6 +502,9 @@ getRegister' dflags is32Bit (CmmRegOff r n) = getRegister' dflags is32Bit $ mangleIndexTree dflags r n +getRegister' dflags is32Bit (CmmMachOp (MO_AlignmentCheck align _) [e])+ = addAlignmentCheck align <$> getRegister' dflags is32Bit e+ -- for 32-bit architectuers, support some 64 -> 32 bit conversions: -- TO_W_(x), TO_W_(x >> 32) @@ -1254,6 +1257,21 @@ || isSuitableFloatingPointLit lit isOperand _ _ = False +-- | Given a 'Register', produce a new 'Register' with an instruction block+-- which will check the value for alignment. Used for @-falignment-sanitisation@.+addAlignmentCheck :: Int -> Register -> Register+addAlignmentCheck align reg =+ case reg of+ Fixed fmt reg code -> Fixed fmt reg (code `appOL` check fmt reg)+ Any fmt f -> Any fmt (\reg -> f reg `appOL` check fmt reg)+ where+ check :: Format -> Reg -> InstrBlock+ check fmt reg =+ ASSERT(not $ isFloatFormat fmt)+ toOL [ TEST fmt (OpImm $ ImmInt $ align-1) (OpReg reg)+ , JXX_GBL NE $ ImmCLbl mkBadAlignmentLabel+ ]+ memConstant :: Int -> CmmLit -> NatM Amode memConstant align lit = do lbl <- getNewLabelNat@@ -1854,6 +1872,72 @@ format = intFormat width lbl = mkCmmCodeLabel primUnitId (fsLit (popCntLabel width)) +genCCall dflags is32Bit (PrimTarget (MO_Pdep width)) dest_regs@[dst]+ args@[src, mask] = do+ let platform = targetPlatform dflags+ if isBmi2Enabled dflags+ then do code_src <- getAnyReg src+ code_mask <- getAnyReg mask+ src_r <- getNewRegNat format+ mask_r <- getNewRegNat format+ let dst_r = getRegisterReg platform False (CmmLocal dst)+ return $ code_src src_r `appOL` code_mask mask_r `appOL`+ (if width == W8 then+ -- The PDEP instruction doesn't take a r/m8+ unitOL (MOVZxL II8 (OpReg src_r ) (OpReg src_r )) `appOL`+ unitOL (MOVZxL II8 (OpReg mask_r) (OpReg mask_r)) `appOL`+ unitOL (PDEP II16 (OpReg mask_r) (OpReg src_r ) dst_r)+ else+ unitOL (PDEP format (OpReg mask_r) (OpReg src_r) dst_r)) `appOL`+ (if width == W8 || width == W16 then+ -- We used a 16-bit destination register above,+ -- so zero-extend+ unitOL (MOVZxL II16 (OpReg dst_r) (OpReg dst_r))+ else nilOL)+ else do+ targetExpr <- cmmMakeDynamicReference dflags+ CallReference lbl+ let target = ForeignTarget targetExpr (ForeignConvention CCallConv+ [NoHint] [NoHint]+ CmmMayReturn)+ genCCall dflags is32Bit target dest_regs args+ where+ format = intFormat width+ lbl = mkCmmCodeLabel primUnitId (fsLit (pdepLabel width))++genCCall dflags is32Bit (PrimTarget (MO_Pext width)) dest_regs@[dst]+ args@[src, mask] = do+ let platform = targetPlatform dflags+ if isBmi2Enabled dflags+ then do code_src <- getAnyReg src+ code_mask <- getAnyReg mask+ src_r <- getNewRegNat format+ mask_r <- getNewRegNat format+ let dst_r = getRegisterReg platform False (CmmLocal dst)+ return $ code_src src_r `appOL` code_mask mask_r `appOL`+ (if width == W8 then+ -- The PEXT instruction doesn't take a r/m8+ unitOL (MOVZxL II8 (OpReg src_r ) (OpReg src_r )) `appOL`+ unitOL (MOVZxL II8 (OpReg mask_r) (OpReg mask_r)) `appOL`+ unitOL (PEXT II16 (OpReg mask_r) (OpReg src_r) dst_r)+ else+ unitOL (PEXT format (OpReg mask_r) (OpReg src_r) dst_r)) `appOL`+ (if width == W8 || width == W16 then+ -- We used a 16-bit destination register above,+ -- so zero-extend+ unitOL (MOVZxL II16 (OpReg dst_r) (OpReg dst_r))+ else nilOL)+ else do+ targetExpr <- cmmMakeDynamicReference dflags+ CallReference lbl+ let target = ForeignTarget targetExpr (ForeignConvention CCallConv+ [NoHint] [NoHint]+ CmmMayReturn)+ genCCall dflags is32Bit target dest_regs args+ where+ format = intFormat width+ lbl = mkCmmCodeLabel primUnitId (fsLit (pextLabel width))+ genCCall dflags is32Bit (PrimTarget (MO_Clz width)) dest_regs@[dst] args@[src] | is32Bit && width == W64 = do -- Fallback to `hs_clz64` on i386@@ -2057,13 +2141,15 @@ MO_F64_Fabs -> case args of [x] -> sse2FabsCode W64 x _ -> panic "genCCall: Wrong number of arguments for fabs"++ MO_F32_Sqrt -> actuallyInlineSSE2Op (\fmt r -> SQRT fmt (OpReg r)) FF32 args+ MO_F64_Sqrt -> actuallyInlineSSE2Op (\fmt r -> SQRT fmt (OpReg r)) FF64 args _other_op -> outOfLineCmmOp op (Just r) args | otherwise -> do l1 <- getNewLabelNat l2 <- getNewLabelNat if sse2- then- outOfLineCmmOp op (Just r) args+ then outOfLineCmmOp op (Just r) args else case op of MO_F32_Sqrt -> actuallyInlineFloatOp GSQRT FF32 args MO_F64_Sqrt -> actuallyInlineFloatOp GSQRT FF64 args@@ -2080,13 +2166,16 @@ _other_op -> outOfLineCmmOp op (Just r) args where- actuallyInlineFloatOp instr format [x]+ actuallyInlineFloatOp = actuallyInlineFloatOp' False+ actuallyInlineSSE2Op = actuallyInlineFloatOp' True++ actuallyInlineFloatOp' usesSSE instr format [x] = do res <- trivialUFCode format (instr format) x any <- anyReg res- return (any (getRegisterReg platform False (CmmLocal r)))+ return (any (getRegisterReg platform usesSSE (CmmLocal r))) - actuallyInlineFloatOp _ _ args- = panic $ "genCCall.actuallyInlineFloatOp: bad number of arguments! ("+ actuallyInlineFloatOp' _ _ _ args+ = panic $ "genCCall.actuallyInlineFloatOp': bad number of arguments! (" ++ show (length args) ++ ")" sse2FabsCode :: Width -> CmmExpr -> NatM InstrBlock@@ -2659,12 +2748,16 @@ MO_Memcpy _ -> fsLit "memcpy" MO_Memset _ -> fsLit "memset" MO_Memmove _ -> fsLit "memmove"+ MO_Memcmp _ -> fsLit "memcmp" MO_PopCnt _ -> fsLit "popcnt" MO_BSwap _ -> fsLit "bswap" MO_Clz w -> fsLit $ clzLabel w MO_Ctz _ -> unsupported + MO_Pdep w -> fsLit $ pdepLabel w+ MO_Pext w -> fsLit $ pextLabel w+ MO_AtomicRMW _ _ -> fsLit "atomicrmw" MO_AtomicRead _ -> fsLit "atomicread" MO_AtomicWrite _ -> fsLit "atomicwrite"@@ -2760,7 +2853,7 @@ = CmmStaticLit (CmmInt 0 (wordWidth dflags)) jumpTableEntryRel (Just blockid) = CmmStaticLit (CmmLabelDiffOff blockLabel lbl 0)- where blockLabel = mkAsmTempLabel (getUnique blockid)+ where blockLabel = blockLbl blockid in map jumpTableEntryRel ids | otherwise = map (jumpTableEntry dflags) ids in CmmData section (1, Statics lbl jumpTable)
nativeGen/X86/Cond.hs view
@@ -8,6 +8,8 @@ where +import GhcPrelude+ data Cond = ALWAYS -- What's really used? ToDo | EQQ
nativeGen/X86/Instr.hs view
@@ -17,6 +17,8 @@ #include "HsVersions.h" #include "nativeGen/NCG.h" +import GhcPrelude+ import X86.Cond import X86.Regs import Instruction@@ -26,7 +28,8 @@ import TargetReg import BlockId-import Hoopl+import Hoopl.Collections+import Hoopl.Label import CodeGen.Platform import Cmm import FastString@@ -289,7 +292,7 @@ | CVTSI2SS Format Operand Reg -- I32/I64 to F32 | CVTSI2SD Format Operand Reg -- I32/I64 to F64 - -- use ADD & SUB for arithmetic. In both cases, operands+ -- use ADD, SUB, and SQRT for arithmetic. In both cases, operands -- are Operand Reg. -- SSE2 floating-point division:@@ -342,6 +345,10 @@ | BSF Format Operand Reg -- bit scan forward | BSR Format Operand Reg -- bit scan reverse + -- bit manipulation instructions+ | PDEP Format Operand Operand Reg -- [BMI2] deposit bits to the specified mask+ | PEXT Format Operand Operand Reg -- [BMI2] extract bits from the specified mask+ -- prefetch | PREFETCH PrefetchVariant Format Operand -- prefetch Variant, addr size, address to prefetch -- variant can be NTA, Lvl0, Lvl1, or Lvl2@@ -447,6 +454,7 @@ CVTSI2SS _ src dst -> mkRU (use_R src []) [dst] CVTSI2SD _ src dst -> mkRU (use_R src []) [dst] FDIV _ src dst -> usageRM src dst+ SQRT _ src dst -> mkRU (use_R src []) [dst] FETCHGOT reg -> mkRU [] [reg] FETCHPC reg -> mkRU [] [reg]@@ -460,6 +468,9 @@ BSF _ src dst -> mkRU (use_R src []) [dst] BSR _ src dst -> mkRU (use_R src []) [dst] + PDEP _ src mask dst -> mkRU (use_R src $ use_R mask []) [dst]+ PEXT _ src mask dst -> mkRU (use_R src $ use_R mask []) [dst]+ -- note: might be a better way to do this PREFETCH _ _ src -> mkRU (use_R src []) [] LOCK i -> x86_regUsageOfInstr platform i@@ -617,6 +628,7 @@ CVTSI2SS fmt src dst -> CVTSI2SS fmt (patchOp src) (env dst) CVTSI2SD fmt src dst -> CVTSI2SD fmt (patchOp src) (env dst) FDIV fmt src dst -> FDIV fmt (patchOp src) (patchOp dst)+ SQRT fmt src dst -> SQRT fmt (patchOp src) (env dst) CALL (Left _) _ -> instr CALL (Right reg) p -> CALL (Right (env reg)) p@@ -635,6 +647,8 @@ CLTD _ -> instr POPCNT fmt src dst -> POPCNT fmt (patchOp src) (env dst)+ PDEP fmt src mask dst -> PDEP fmt (patchOp src) (patchOp mask) (env dst)+ PEXT fmt src mask dst -> PEXT fmt (patchOp src) (patchOp mask) (env dst) BSF fmt src dst -> BSF fmt (patchOp src) (env dst) BSR fmt src dst -> BSR fmt (patchOp src) (env dst) @@ -1030,8 +1044,8 @@ shortcutLabel :: (BlockId -> Maybe JumpDest) -> CLabel -> CLabel shortcutLabel fn lab- | Just uq <- maybeAsmTemp lab = shortBlockId fn emptyUniqSet (mkBlockId uq)- | otherwise = lab+ | Just blkId <- maybeLocalBlockLabel lab = shortBlockId fn emptyUniqSet blkId+ | otherwise = lab shortcutStatic :: (BlockId -> Maybe JumpDest) -> CmmStatic -> CmmStatic shortcutStatic fn (CmmStaticLit (CmmLabel lab))@@ -1051,8 +1065,8 @@ shortBlockId fn seen blockid = case (elementOfUniqSet uq seen, fn blockid) of- (True, _) -> mkAsmTempLabel uq- (_, Nothing) -> mkAsmTempLabel uq+ (True, _) -> blockLbl blockid+ (_, Nothing) -> blockLbl blockid (_, Just (DestBlockId blockid')) -> shortBlockId fn (addOneToUniqSet seen uq) blockid' (_, Just (DestImm (ImmCLbl lbl))) -> lbl (_, _other) -> panic "shortBlockId"
nativeGen/X86/Ppr.hs view
@@ -23,6 +23,8 @@ #include "HsVersions.h" #include "nativeGen/NCG.h" +import GhcPrelude+ import X86.Regs import X86.Instr import X86.Cond@@ -32,12 +34,14 @@ import PprBase -import Hoopl+import Hoopl.Collections+import Hoopl.Label import BasicTypes (Alignment) import DynFlags import Cmm hiding (topInfoTable)+import BlockId import CLabel-import Unique ( pprUniqueAlways, Uniquable(..) )+import Unique ( pprUniqueAlways ) import Platform import FastString import Outputable@@ -125,7 +129,7 @@ (if debugLevel dflags > 0 then ppr (mkAsmTempEndLabel asmLbl) <> char ':' else empty) where- asmLbl = mkAsmTempLabel (getUnique blockid)+ asmLbl = blockLbl blockid maybe_infotable = case mapLookup blockid info_env of Nothing -> empty Just (Statics info_lbl info) ->@@ -515,7 +519,7 @@ asmComment :: SDoc -> SDoc-asmComment c = ifPprDebug $ text "# " <> c+asmComment c = whenPprDebug $ text "# " <> c pprInstr :: Instr -> SDoc @@ -644,6 +648,9 @@ pprInstr (BSF format src dst) = pprOpOp (sLit "bsf") format src (OpReg dst) pprInstr (BSR format src dst) = pprOpOp (sLit "bsr") format src (OpReg dst) +pprInstr (PDEP format src mask dst) = pprFormatOpOpReg (sLit "pdep") format src mask dst+pprInstr (PEXT format src mask dst) = pprFormatOpOpReg (sLit "pext") format src mask dst+ pprInstr (PREFETCH NTA format src ) = pprFormatOp_ (sLit "prefetchnta") format src pprInstr (PREFETCH Lvl0 format src) = pprFormatOp_ (sLit "prefetcht0") format src pprInstr (PREFETCH Lvl1 format src) = pprFormatOp_ (sLit "prefetcht1") format src@@ -701,7 +708,7 @@ pprInstr (JXX cond blockid) = pprCondInstr (sLit "j") cond (ppr lab)- where lab = mkAsmTempLabel (getUnique blockid)+ where lab = blockLbl blockid pprInstr (JXX_GBL cond imm) = pprCondInstr (sLit "j") cond (pprImm imm) @@ -724,6 +731,7 @@ pprInstr (MUL2 format op) = pprFormatOp (sLit "mul") format op pprInstr (FDIV format op1 op2) = pprFormatOpOp (sLit "div") format op1 op2+pprInstr (SQRT format op1 op2) = pprFormatOpReg (sLit "sqrt") format op1 op2 pprInstr (CVTSS2SD from to) = pprRegReg (sLit "cvtss2sd") from to pprInstr (CVTSD2SS from to) = pprRegReg (sLit "cvtsd2ss") from to@@ -1257,6 +1265,16 @@ pprReg format reg3 ] +pprFormatOpOpReg :: LitString -> Format -> Operand -> Operand -> Reg -> SDoc+pprFormatOpOpReg name format op1 op2 reg3+ = hcat [+ pprMnemonic name format,+ pprOperand format op1,+ comma,+ pprOperand format op2,+ comma,+ pprReg format reg3+ ] pprFormatAddrReg :: LitString -> Format -> AddrMode -> Reg -> SDoc pprFormatAddrReg name format op dst
nativeGen/X86/RegInfo.hs view
@@ -9,6 +9,8 @@ #include "nativeGen/NCG.h" #include "HsVersions.h" +import GhcPrelude+ import Format import Reg
nativeGen/X86/Regs.hs view
@@ -48,6 +48,8 @@ #include "nativeGen/NCG.h" #include "HsVersions.h" +import GhcPrelude+ import CodeGen.Platform import Reg import RegClass@@ -58,8 +60,10 @@ import Outputable import Platform +import qualified Data.Array as A+ -- | regSqueeze_class reg--- Calculuate the maximum number of register colors that could be+-- Calculate the maximum number of register colors that could be -- denied to a node of this class due to having this reg -- as a neighbour. --@@ -234,7 +238,6 @@ floatregnos :: Platform -> [RegNo] floatregnos platform = fakeregnos ++ xmmregnos platform - -- argRegs is the set of regs which are read for an n-argument call to C. -- For archs which pass all args on the stack (x86), is empty. -- Sparc passes up to the first 6 args in regs.@@ -267,13 +270,13 @@ | n >= firstxmm = "%xmm" ++ show (n-firstxmm) | n >= firstfake = "%fake" ++ show (n-firstfake) | n >= 8 = "%r" ++ show n- | otherwise = regNames platform !! n+ | otherwise = regNames platform A.! n -regNames :: Platform -> [String]+regNames :: Platform -> A.Array Int String regNames platform = if target32Bit platform- then ["%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp"]- else ["%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi", "%rbp", "%rsp"]+ then A.listArray (0,8) ["%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp"]+ else A.listArray (0,8) ["%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi", "%rbp", "%rsp"] @@ -404,7 +407,10 @@ | target32Bit platform = [eax,ecx,edx] ++ map regSingle (floatregnos platform) | platformOS platform == OSMinGW32 = [rax,rcx,rdx,r8,r9,r10,r11]- ++ map regSingle (floatregnos platform)+ -- Only xmm0-5 are caller-saves registers on 64bit windows.+ -- ( https://docs.microsoft.com/en-us/cpp/build/register-usage )+ -- For details check the Win64 ABI.+ ++ map regSingle fakeregnos ++ map xmm [0 .. 5] | otherwise -- all xmm regs are caller-saves -- caller-saves registers
parser/ApiAnnotation.hs view
@@ -13,6 +13,8 @@ LRdrName -- Exists for haddocks only ) where +import GhcPrelude+ import RdrName import Outputable import SrcLoc
parser/Ctype.hs view
@@ -16,6 +16,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Data.Int ( Int32 ) import Data.Bits ( Bits((.&.)) ) import Data.Char ( ord, chr )
parser/HaddockUtils.hs view
@@ -1,6 +1,8 @@ module HaddockUtils where +import GhcPrelude+ import HsSyn import SrcLoc
parser/Lexer.x view
@@ -75,19 +75,19 @@ moveAnnotations ) where +import GhcPrelude+ -- base import Control.Monad-#if __GLASGOW_HASKELL__ > 710-import Control.Monad.Fail-#endif+import Control.Monad.Fail as MonadFail import Data.Bits import Data.Char import Data.List import Data.Maybe import Data.Word -import Data.IntSet (IntSet)-import qualified Data.IntSet as IntSet+import EnumSet (EnumSet)+import qualified EnumSet -- ghc-boot import qualified GHC.LanguageExtensions as LangExt@@ -105,7 +105,7 @@ import StringBuffer import FastString import UniqFM-import Util ( readRational )+import Util ( readRational, readHexRational ) -- compiler/main import ErrUtils@@ -114,7 +114,8 @@ -- compiler/basicTypes import SrcLoc import Module-import BasicTypes ( InlineSpec(..), RuleMatchInfo(..), FractionalLit(..),+import BasicTypes ( InlineSpec(..), RuleMatchInfo(..),+ IntegralLit(..), FractionalLit(..), SourceText(..) ) -- compiler/parser@@ -128,38 +129,38 @@ -- NB: The logic behind these definitions is also reflected in basicTypes/Lexeme.hs -- Any changes here should likely be reflected there.-$unispace = \x05 -- Trick Alex into handling Unicode. See alexGetByte.+$unispace = \x05 -- Trick Alex into handling Unicode. See [Unicode in Alex]. $nl = [\n\r\f] $whitechar = [$nl\v\ $unispace] $white_no_nl = $whitechar # \n -- TODO #8424 $tab = \t $ascdigit = 0-9-$unidigit = \x03 -- Trick Alex into handling Unicode. See alexGetByte.+$unidigit = \x03 -- Trick Alex into handling Unicode. See [Unicode in Alex]. $decdigit = $ascdigit -- for now, should really be $digit (ToDo) $digit = [$ascdigit $unidigit] $special = [\(\)\,\;\[\]\`\{\}] $ascsymbol = [\!\#\$\%\&\*\+\.\/\<\=\>\?\@\\\^\|\-\~\:]-$unisymbol = \x04 -- Trick Alex into handling Unicode. See alexGetByte.+$unisymbol = \x04 -- Trick Alex into handling Unicode. See [Unicode in Alex]. $symbol = [$ascsymbol $unisymbol] # [$special \_\"\'] -$unilarge = \x01 -- Trick Alex into handling Unicode. See alexGetByte.+$unilarge = \x01 -- Trick Alex into handling Unicode. See [Unicode in Alex]. $asclarge = [A-Z] $large = [$asclarge $unilarge] -$unismall = \x02 -- Trick Alex into handling Unicode. See alexGetByte.+$unismall = \x02 -- Trick Alex into handling Unicode. See [Unicode in Alex]. $ascsmall = [a-z] $small = [$ascsmall $unismall \_] -$unigraphic = \x06 -- Trick Alex into handling Unicode. See alexGetByte.+$unigraphic = \x06 -- Trick Alex into handling Unicode. See [Unicode in Alex]. $graphic = [$small $large $symbol $digit $special $unigraphic \"\'] $binit = 0-1 $octit = 0-7 $hexit = [$decdigit A-F a-f] -$uniidchar = \x07 -- Trick Alex into handling Unicode. See alexGetByte.+$uniidchar = \x07 -- Trick Alex into handling Unicode. See [Unicode in Alex]. $idchar = [$small $large $digit $uniidchar \'] $pragmachar = [$small $large $digit]@@ -181,6 +182,7 @@ @octal = $octit+ @hexadecimal = $hexit+ @exponent = [eE] [\-\+]? @decimal+@bin_exponent = [pP] [\-\+]? @decimal @qual = (@conid \.)+ @qvarid = @qual @varid@@ -189,6 +191,7 @@ @qconsym = @qual @consym @floating_point = @decimal \. @decimal @exponent? | @decimal @exponent+@hex_floating_point = @hexadecimal \. @hexadecimal @bin_exponent? | @hexadecimal @bin_exponent -- normal signed numerical literals can only be explicitly negative, -- not explicitly positive (contrast @exponent)@@ -497,6 +500,9 @@ -- Normal rational literals (:: Fractional a => a, from Rational) @floating_point { strtoken tok_float } @negative @floating_point / { ifExtension negativeLiteralsEnabled } { strtoken tok_float }+ 0[xX] @hex_floating_point / { ifExtension hexFloatLiteralsEnabled } { strtoken tok_hex_float }+ @negative 0[xX]@hex_floating_point / { ifExtension hexFloatLiteralsEnabled `alexAndPred`+ ifExtension negativeLiteralsEnabled } { strtoken tok_hex_float } } <0> {@@ -634,7 +640,8 @@ | ITrules_prag SourceText | ITwarning_prag SourceText | ITdeprecated_prag SourceText- | ITline_prag+ | ITline_prag SourceText -- not usually produced, see 'use_pos_prags'+ | ITcolumn_prag SourceText -- not usually produced, see 'use_pos_prags' | ITscc_prag SourceText | ITgenerated_prag SourceText | ITcore_prag SourceText -- hdaume: core annotations@@ -707,7 +714,7 @@ | ITchar SourceText Char -- Note [Literal source text] in BasicTypes | ITstring SourceText FastString -- Note [Literal source text] in BasicTypes- | ITinteger SourceText Integer -- Note [Literal source text] in BasicTypes+ | ITinteger IntegralLit -- Note [Literal source text] in BasicTypes | ITrational FractionalLit | ITprimchar SourceText Char -- Note [Literal source text] in BasicTypes@@ -1134,6 +1141,27 @@ let !src = lexemeToString buf len return (L span (ITrules_prag (SourceText src))) +-- When 'use_pos_prags' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+linePrag :: Action+linePrag span buf len = do+ ps <- getPState+ if use_pos_prags ps+ then begin line_prag2 span buf len+ else let !src = lexemeToString buf len+ in return (L span (ITline_prag (SourceText src)))++-- When 'use_pos_prags' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+columnPrag :: Action+columnPrag span buf len = do+ ps <- getPState+ let !src = lexemeToString buf len+ if use_pos_prags ps+ then begin column_prag span buf len+ else let !src = lexemeToString buf len+ in return (L span (ITcolumn_prag (SourceText src)))+ endPrag :: Action endPrag span _buf _len = do setExts (.&. complement (xbit InRulePragBit))@@ -1276,15 +1304,21 @@ $! transint $ parseUnsignedInteger (offsetBytes transbuf buf) (subtract translen len) radix char_to_int --- some conveniences for use with tok_integral tok_num :: (Integer -> Integer)- -> Int -> Int- -> (Integer, (Char->Int)) -> Action-tok_num = tok_integral ITinteger+ -> Int -> Int+ -> (Integer, (Char->Int)) -> Action+tok_num = tok_integral itint+ where+ itint st@(SourceText ('-':str)) val = ITinteger (((IL $! st) $! True) $! val)+ itint st@(SourceText str ) val = ITinteger (((IL $! st) $! False) $! val)+ itint st@(NoSourceText ) val = ITinteger (((IL $! st) $! (val < 0)) $! val)+ tok_primint :: (Integer -> Integer) -> Int -> Int -> (Integer, (Char->Int)) -> Action tok_primint = tok_integral ITprimint++ tok_primword :: Int -> Int -> (Integer, (Char->Int)) -> Action tok_primword = tok_integral ITprimword positive@@ -1300,11 +1334,22 @@ -- readRational can understand negative rationals, exponents, everything. tok_float, tok_primfloat, tok_primdouble :: String -> Token tok_float str = ITrational $! readFractionalLit str+tok_hex_float str = ITrational $! readHexFractionalLit str tok_primfloat str = ITprimfloat $! readFractionalLit str tok_primdouble str = ITprimdouble $! readFractionalLit str readFractionalLit :: String -> FractionalLit-readFractionalLit str = (FL $! str) $! readRational str+readFractionalLit str = ((FL $! (SourceText str)) $! is_neg) $! readRational str+ where is_neg = case str of ('-':_) -> True+ _ -> False+readHexFractionalLit :: String -> FractionalLit+readHexFractionalLit str =+ FL { fl_text = SourceText str+ , fl_neg = case str of+ '-' : _ -> True+ _ -> False+ , fl_value = readHexRational str+ } -- ----------------------------------------------------------------------------- -- Layout processing@@ -1791,23 +1836,27 @@ data ParseResult a = POk PState a | PFailed- SrcSpan -- The start and end of the text span related to- -- the error. Might be used in environments which can- -- show this span, e.g. by highlighting it.- MsgDoc -- The error message+ (DynFlags -> Messages) -- A function that returns warnings that+ -- accumulated during parsing, including+ -- the warnings related to tabs.+ SrcSpan -- The start and end of the text span related+ -- to the error. Might be used in environments+ -- which can show this span, e.g. by+ -- highlighting it.+ MsgDoc -- The error message -- | Test whether a 'WarningFlag' is set warnopt :: WarningFlag -> ParserFlags -> Bool-warnopt f options = fromEnum f `IntSet.member` pWarningFlags options+warnopt f options = f `EnumSet.member` pWarningFlags options -- | Test whether a 'LangExt.Extension' is set extopt :: LangExt.Extension -> ParserFlags -> Bool-extopt f options = fromEnum f `IntSet.member` pExtensionFlags options+extopt f options = f `EnumSet.member` pExtensionFlags options -- | The subset of the 'DynFlags' used by the parser data ParserFlags = ParserFlags {- pWarningFlags :: IntSet- , pExtensionFlags :: IntSet+ pWarningFlags :: EnumSet WarningFlag+ , pExtensionFlags :: EnumSet LangExt.Extension , pThisPackage :: UnitId -- ^ key of package currently being compiled , pExtsBitmap :: !ExtsBitmap -- ^ bitmap of permitted extensions }@@ -1846,6 +1895,10 @@ -- token doesn't need to close anything: alr_justClosedExplicitLetBlock :: Bool, + -- If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}'+ -- update the 'loc' field. Otherwise, those pragmas are lexed as tokens.+ use_pos_prags :: Bool,+ -- The next three are used to implement Annotations giving the -- locations of 'noise' tokens in the source, so that users of -- the GHC API can do source to source conversions.@@ -1879,12 +1932,10 @@ instance Monad P where (>>=) = thenP- fail = failP+ fail = MonadFail.fail -#if __GLASGOW_HASKELL__ > 710 instance MonadFail P where fail = failP-#endif returnP :: a -> P a returnP a = a `seq` (P $ \s -> POk s a)@@ -1893,19 +1944,27 @@ (P m) `thenP` k = P $ \ s -> case m s of POk s1 a -> (unP (k a)) s1- PFailed span err -> PFailed span err+ PFailed warnFn span err -> PFailed warnFn span err failP :: String -> P a-failP msg = P $ \s -> PFailed (RealSrcSpan (last_loc s)) (text msg)+failP msg =+ P $ \s ->+ PFailed (getMessages s) (RealSrcSpan (last_loc s)) (text msg) failMsgP :: String -> P a-failMsgP msg = P $ \s -> PFailed (RealSrcSpan (last_loc s)) (text msg)+failMsgP msg =+ P $ \s ->+ PFailed (getMessages s) (RealSrcSpan (last_loc s)) (text msg) failLocMsgP :: RealSrcLoc -> RealSrcLoc -> String -> P a-failLocMsgP loc1 loc2 str = P $ \_ -> PFailed (RealSrcSpan (mkRealSrcSpan loc1 loc2)) (text str)+failLocMsgP loc1 loc2 str =+ P $ \s ->+ PFailed (getMessages s) (RealSrcSpan (mkRealSrcSpan loc1 loc2)) (text str) failSpanMsgP :: SrcSpan -> SDoc -> P a-failSpanMsgP span msg = P $ \_ -> PFailed span msg+failSpanMsgP span msg =+ P $ \s ->+ PFailed (getMessages s) span msg getPState :: P PState getPState = P $ \s -> POk s s@@ -1949,27 +2008,29 @@ data AlexInput = AI RealSrcLoc StringBuffer -alexInputPrevChar :: AlexInput -> Char-alexInputPrevChar (AI _ buf) = prevChar buf '\n'+{-+Note [Unicode in Alex]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Although newer versions of Alex support unicode, this grammar is processed with+the old style '--latin1' behaviour. This means that when implementing the+functions --- backwards compatibility for Alex 2.x-alexGetChar :: AlexInput -> Maybe (Char,AlexInput)-alexGetChar inp = case alexGetByte inp of- Nothing -> Nothing- Just (b,i) -> c `seq` Just (c,i)- where c = chr $ fromIntegral b+ alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)+ alexInputPrevChar :: AlexInput -> Char -alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)-alexGetByte (AI loc s)- | atEnd s = Nothing- | otherwise = byte `seq` loc' `seq` s' `seq`- --trace (show (ord c)) $- Just (byte, (AI loc' s'))- where (c,s') = nextChar s- loc' = advanceSrcLoc loc c- byte = fromIntegral $ ord adj_c+which Alex uses to to take apart our 'AlexInput', we must - non_graphic = '\x00'+ * return a latin1 character in the 'Word8' that 'alexGetByte' expects+ * return a latin1 character in 'alexInputPrevChar'.++We handle this in 'adjustChar' by squishing entire classes of unicode+characters into single bytes.+-}++{-# INLINE adjustChar #-}+adjustChar :: Char -> Word8+adjustChar c = fromIntegral $ ord adj_c+ where non_graphic = '\x00' upper = '\x01' lower = '\x02' digit = '\x03'@@ -2015,6 +2076,32 @@ Space -> space _other -> non_graphic +-- Getting the previous 'Char' isn't enough here - we need to convert it into+-- the same format that 'alexGetByte' would have produced.+--+-- See Note [Unicode in Alex] and #13986.+alexInputPrevChar :: AlexInput -> Char+alexInputPrevChar (AI _ buf) = chr (fromIntegral (adjustChar pc))+ where pc = prevChar buf '\n'++-- backwards compatibility for Alex 2.x+alexGetChar :: AlexInput -> Maybe (Char,AlexInput)+alexGetChar inp = case alexGetByte inp of+ Nothing -> Nothing+ Just (b,i) -> c `seq` Just (c,i)+ where c = chr $ fromIntegral b++-- See Note [Unicode in Alex]+alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)+alexGetByte (AI loc s)+ | atEnd s = Nothing+ | otherwise = byte `seq` loc' `seq` s' `seq`+ --trace (show (ord c)) $+ Just (byte, (AI loc' s'))+ where (c,s') = nextChar s+ loc' = advanceSrcLoc loc c+ byte = adjustChar c+ -- This version does not squash unicode characters, it is used when -- lexing strings. alexGetChar' :: AlexInput -> Maybe (Char,AlexInput)@@ -2157,6 +2244,7 @@ | LambdaCaseBit | BinaryLiteralsBit | NegativeLiteralsBit+ | HexFloatLiteralsBit | TypeApplicationsBit | StaticPointersBit deriving Enum@@ -2219,6 +2307,8 @@ binaryLiteralsEnabled = xtest BinaryLiteralsBit negativeLiteralsEnabled :: ExtsBitmap -> Bool negativeLiteralsEnabled = xtest NegativeLiteralsBit+hexFloatLiteralsEnabled :: ExtsBitmap -> Bool+hexFloatLiteralsEnabled = xtest HexFloatLiteralsBit patternSynonymsEnabled :: ExtsBitmap -> Bool patternSynonymsEnabled = xtest PatternSynonymsBit typeApplicationEnabled :: ExtsBitmap -> Bool@@ -2276,6 +2366,7 @@ .|. LambdaCaseBit `setBitIf` xopt LangExt.LambdaCase flags .|. BinaryLiteralsBit `setBitIf` xopt LangExt.BinaryLiterals flags .|. NegativeLiteralsBit `setBitIf` xopt LangExt.NegativeLiterals flags+ .|. HexFloatLiteralsBit `setBitIf` xopt LangExt.HexFloatLiterals flags .|. PatternSynonymsBit `setBitIf` xopt LangExt.PatternSynonyms flags .|. TypeApplicationsBit `setBitIf` xopt LangExt.TypeApplications flags .|. StaticPointersBit `setBitIf` xopt LangExt.StaticPointers flags@@ -2310,6 +2401,7 @@ alr_context = [], alr_expecting_ocurly = Nothing, alr_justClosedExplicitLetBlock = False,+ use_pos_prags = True, annotations = [], comment_q = [], annotations_comments = []@@ -2366,8 +2458,10 @@ popContext = P $ \ s@(PState{ buffer = buf, options = o, context = ctx, last_len = len, last_loc = last_loc }) -> case ctx of- (_:tl) -> POk s{ context = tl } ()- [] -> PFailed (RealSrcSpan last_loc) (srcParseErr o buf len)+ (_:tl) ->+ POk s{ context = tl } ()+ [] ->+ PFailed (getMessages s) (RealSrcSpan last_loc) (srcParseErr o buf len) -- Push a new layout context at the indentation of the last token read. pushCurrentContext :: GenSemic -> P ()@@ -2405,14 +2499,18 @@ $$ ppWhen (not th_enabled && token == "$") -- #7396 (text "Perhaps you intended to use TemplateHaskell") $$ ppWhen (token == "<-")- (text "Perhaps this statement should be within a 'do' block?")+ (if mdoInLast100+ then text "Perhaps you intended to use RecursiveDo"+ else text "Perhaps this statement should be within a 'do' block?") $$ ppWhen (token == "=") (text "Perhaps you need a 'let' in a 'do' block?" $$ text "e.g. 'let x = 5' instead of 'x = 5'")- $$ ppWhen (not ps_enabled && pattern == "pattern") -- #12429+ $$ ppWhen (not ps_enabled && pattern == "pattern ") -- #12429 (text "Perhaps you intended to use PatternSynonyms") where token = lexemeToString (offsetBytes (-len) buf) len- pattern = lexemeToString (offsetBytes (-len - 8) buf) 7+ pattern = decodePrevNChars 8 buf+ last100 = decodePrevNChars 100 buf+ mdoInLast100 = "mdo" `isInfixOf` last100 th_enabled = extopt LangExt.TemplateHaskell options ps_enabled = extopt LangExt.PatternSynonyms options @@ -2420,9 +2518,9 @@ -- the location of the error. This is the entry point for errors -- detected during parsing. srcParseFail :: P a-srcParseFail = P $ \PState{ buffer = buf, options = o, last_len = len,+srcParseFail = P $ \s@PState{ buffer = buf, options = o, last_len = len, last_loc = last_loc } ->- PFailed (RealSrcSpan last_loc) (srcParseErr o buf len)+ PFailed (getMessages s) (RealSrcSpan last_loc) (srcParseErr o buf len) -- A lexical error is reported at a particular position in the source file, -- not over a token range.@@ -2511,7 +2609,7 @@ (_, ALRLayout _ col : _ls, Just expectingOCurly) | (thisCol > col) || (thisCol == col &&- isNonDecreasingIntentation expectingOCurly) ->+ isNonDecreasingIndentation expectingOCurly) -> do setAlrExpectingOCurly Nothing setALRContext (ALRLayout expectingOCurly thisCol : context) setNextToken t@@ -2655,9 +2753,9 @@ isALRclose ITcubxparen = True isALRclose _ = False -isNonDecreasingIntentation :: ALRLayout -> Bool-isNonDecreasingIntentation ALRLayoutDo = True-isNonDecreasingIntentation _ = False+isNonDecreasingIndentation :: ALRLayout -> Bool+isNonDecreasingIndentation ALRLayoutDo = True+isNonDecreasingIndentation _ = False containsCommas :: Token -> Bool containsCommas IToparen = True@@ -2715,14 +2813,14 @@ lexTokenStream :: StringBuffer -> RealSrcLoc -> DynFlags -> ParseResult [Located Token] lexTokenStream buf loc dflags = unP go initState where dflags' = gopt_set (gopt_unset dflags Opt_Haddock) Opt_KeepRawTokenStream- initState = mkPState dflags' buf loc+ initState = (mkPState dflags' buf loc) { use_pos_prags = False } go = do ltok <- lexer False return case ltok of L _ ITeof -> return [] _ -> liftM (ltok:) go -linePrags = Map.singleton "line" (begin line_prag2)+linePrags = Map.singleton "line" linePrag fileHeaderPrags = Map.fromList([("options", lex_string_prag IToptions_prag), ("options_ghc", lex_string_prag IToptions_prag),@@ -2767,7 +2865,7 @@ ("incoherent", strtoken (\s -> ITincoherent_prag (SourceText s))), ("ctype", strtoken (\s -> ITctype (SourceText s))), ("complete", strtoken (\s -> ITcomplete_prag (SourceText s))),- ("column", begin column_prag)+ ("column", columnPrag) ] twoWordPrags = Map.fromList([
parser/Parser.y view
@@ -83,7 +83,7 @@ -- compiler/utils import Util ( looksLikePackageName )-import Prelude+import GhcPrelude import qualified GHC.LanguageExtensions as LangExt }@@ -499,7 +499,7 @@ CHAR { L _ (ITchar _ _) } STRING { L _ (ITstring _ _) }- INTEGER { L _ (ITinteger _ _) }+ INTEGER { L _ (ITinteger _) } RATIONAL { L _ (ITrational _) } PRIMCHAR { L _ (ITprimchar _ _) }@@ -661,7 +661,7 @@ -- either, and DEPRECATED is only expected to be used by people who really -- know what they are doing. :-) -signature :: { Located (HsModule RdrName) }+signature :: { Located (HsModule GhcPs) } : maybedocheader 'signature' modid maybemodwarning maybeexports 'where' body {% fileSrcSpan >>= \ loc -> ams (L loc (HsModule (Just $3) $5 (fst $ snd $7)@@ -669,7 +669,7 @@ ) ([mj AnnSignature $2, mj AnnWhere $6] ++ fst $7) } -module :: { Located (HsModule RdrName) }+module :: { Located (HsModule GhcPs) } : maybedocheader 'module' modid maybemodwarning maybeexports 'where' body {% fileSrcSpan >>= \ loc -> ams (L loc (HsModule (Just $3) $5 (fst $ snd $7)@@ -702,23 +702,23 @@ | {- empty -} { Nothing } body :: { ([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName])) }+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])) } : '{' top '}' { (moc $1:mcc $3:(fst $2) , snd $2) } | vocurly top close { (fst $2, snd $2) } body2 :: { ([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName])) }+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])) } : '{' top '}' { (moc $1:mcc $3 :(fst $2), snd $2) } | missing_module_keyword top close { ([],snd $2) } top :: { ([AddAnn]- ,([LImportDecl RdrName], [LHsDecl RdrName])) }+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])) } : semis top1 { ($1, $2) } -top1 :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }+top1 :: { ([LImportDecl GhcPs], [LHsDecl GhcPs]) } : importdecls_semi topdecls_semi { (reverse $1, cvTopDecls $2) } | importdecls_semi topdecls { (reverse $1, cvTopDecls $2) } | importdecls { (reverse $1, []) }@@ -726,7 +726,7 @@ ----------------------------------------------------------------------------- -- Module declaration & imports only -header :: { Located (HsModule RdrName) }+header :: { Located (HsModule GhcPs) } : maybedocheader 'module' modid maybemodwarning maybeexports 'where' header_body {% fileSrcSpan >>= \ loc -> ams (L loc (HsModule (Just $3) $5 $7 [] $4 $1@@ -740,35 +740,35 @@ return (L loc (HsModule Nothing Nothing $1 [] Nothing Nothing)) } -header_body :: { [LImportDecl RdrName] }+header_body :: { [LImportDecl GhcPs] } : '{' header_top { $2 } | vocurly header_top { $2 } -header_body2 :: { [LImportDecl RdrName] }+header_body2 :: { [LImportDecl GhcPs] } : '{' header_top { $2 } | missing_module_keyword header_top { $2 } -header_top :: { [LImportDecl RdrName] }+header_top :: { [LImportDecl GhcPs] } : semis header_top_importdecls { $2 } -header_top_importdecls :: { [LImportDecl RdrName] }+header_top_importdecls :: { [LImportDecl GhcPs] } : importdecls_semi { $1 } | importdecls { $1 } ----------------------------------------------------------------------------- -- The Export List -maybeexports :: { (Maybe (Located [LIE RdrName])) }+maybeexports :: { (Maybe (Located [LIE GhcPs])) } : '(' exportlist ')' {% ams (sLL $1 $> ()) [mop $1,mcp $3] >> return (Just (sLL $1 $> (fromOL $2))) } | {- empty -} { Nothing } -exportlist :: { OrdList (LIE RdrName) }+exportlist :: { OrdList (LIE GhcPs) } : expdoclist ',' expdoclist {% addAnnotation (oll $1) AnnComma (gl $2) >> return ($1 `appOL` $3) } | exportlist1 { $1 } -exportlist1 :: { OrdList (LIE RdrName) }+exportlist1 :: { OrdList (LIE GhcPs) } : expdoclist export expdoclist ',' exportlist1 {% (addAnnotation (oll ($1 `appOL` $2 `appOL` $3)) AnnComma (gl $4) ) >>@@ -776,11 +776,11 @@ | expdoclist export expdoclist { $1 `appOL` $2 `appOL` $3 } | expdoclist { $1 } -expdoclist :: { OrdList (LIE RdrName) }+expdoclist :: { OrdList (LIE GhcPs) } : exp_doc expdoclist { $1 `appOL` $2 } | {- empty -} { nilOL } -exp_doc :: { OrdList (LIE RdrName) }+exp_doc :: { OrdList (LIE GhcPs) } : docsection { unitOL (sL1 $1 (case (unLoc $1) of (n, doc) -> IEGroup n doc)) } | docnamed { unitOL (sL1 $1 (IEDocNamed ((fst . unLoc) $1))) } | docnext { unitOL (sL1 $1 (IEDoc (unLoc $1))) }@@ -788,7 +788,7 @@ -- No longer allow things like [] and (,,,) to be exported -- They are built in syntax, always available-export :: { OrdList (LIE RdrName) }+export :: { OrdList (LIE GhcPs) } : qcname_ext export_subspec {% mkModuleImpExp $1 (snd $ unLoc $2) >>= \ie -> amsu (sLL $1 $> ie) (fst $ unLoc $2) } | 'module' modid {% amsu (sLL $1 $> (IEModuleContents $2))@@ -855,19 +855,19 @@ | {- empty -} { [] } -- No trailing semicolons, non-empty-importdecls :: { [LImportDecl RdrName] }+importdecls :: { [LImportDecl GhcPs] } importdecls : importdecls_semi importdecl { $2 : $1 } -- May have trailing semicolons, can be empty-importdecls_semi :: { [LImportDecl RdrName] }+importdecls_semi :: { [LImportDecl GhcPs] } importdecls_semi : importdecls_semi importdecl semis1 {% ams $2 $3 >> return ($2 : $1) } | {- empty -} { [] } -importdecl :: { LImportDecl RdrName }+importdecl :: { LImportDecl GhcPs } : 'import' maybe_src maybe_safe optqualified maybe_pkg modid maybeas maybeimpspec {% ams (L (comb4 $1 $6 (snd $7) $8) $ ImportDecl { ideclSourceSrc = snd $ fst $2@@ -907,14 +907,14 @@ ,sLL $1 $> (Just $2)) } | {- empty -} { ([],noLoc Nothing) } -maybeimpspec :: { Located (Maybe (Bool, Located [LIE RdrName])) }+maybeimpspec :: { Located (Maybe (Bool, Located [LIE GhcPs])) } : impspec {% let (b, ie) = unLoc $1 in checkImportSpec ie >>= \checkedIe -> return (L (gl $1) (Just (b, checkedIe))) } | {- empty -} { noLoc Nothing } -impspec :: { Located (Bool, Located [LIE RdrName]) }+impspec :: { Located (Bool, Located [LIE GhcPs]) } : '(' exportlist ')' {% ams (sLL $1 $> (False, sLL $1 $> $ fromOL $2)) [mop $1,mcp $3] }@@ -928,7 +928,7 @@ prec :: { Located (SourceText,Int) } : {- empty -} { noLoc (NoSourceText,9) } | INTEGER- {% checkPrecP (sL1 $1 (getINTEGERs $1,fromInteger (getINTEGER $1))) }+ {% checkPrecP (sL1 $1 (getINTEGERs $1,fromInteger (il_value (getINTEGER $1)))) } infix :: { Located FixityDirection } : 'infix' { sL1 $1 InfixN }@@ -944,15 +944,15 @@ -- Top-Level Declarations -- No trailing semicolons, non-empty-topdecls :: { OrdList (LHsDecl RdrName) }+topdecls :: { OrdList (LHsDecl GhcPs) } : topdecls_semi topdecl { $1 `snocOL` $2 } -- May have trailing semicolons, can be empty-topdecls_semi :: { OrdList (LHsDecl RdrName) }+topdecls_semi :: { OrdList (LHsDecl GhcPs) } : topdecls_semi topdecl semis1 {% ams $2 $3 >> return ($1 `snocOL` $2) } | {- empty -} { nilOL } -topdecl :: { LHsDecl RdrName }+topdecl :: { LHsDecl GhcPs } : cl_decl { sL1 $1 (TyClD (unLoc $1)) } | ty_decl { sL1 $1 (TyClD (unLoc $1)) } | inst_decl { sL1 $1 (InstD (unLoc $1)) }@@ -1007,14 +1007,14 @@ -- Type classes ---cl_decl :: { LTyClDecl RdrName }+cl_decl :: { LTyClDecl GhcPs } : 'class' tycl_hdr fds where_cls {% amms (mkClassDecl (comb4 $1 $2 $3 $4) $2 $3 (snd $ unLoc $4)) (mj AnnClass $1:(fst $ unLoc $3)++(fst $ unLoc $4)) } -- Type declarations (toplevel) ---ty_decl :: { LTyClDecl RdrName }+ty_decl :: { LTyClDecl GhcPs } -- ordinary type synonyms : 'type' type '=' ctypedoc -- Note ctype, not sigtype, on the right of '='@@ -1063,7 +1063,7 @@ (snd $ unLoc $4) Nothing) (mj AnnData $1:mj AnnFamily $2:(fst $ unLoc $4)) } -inst_decl :: { LInstDecl RdrName }+inst_decl :: { LInstDecl GhcPs } : 'instance' overlap_pragma inst_type where_inst {% do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc $4) ; let cid = ClsInstDecl { cid_poly_ty = $3, cid_binds = binds@@ -1120,12 +1120,12 @@ -- Injective type families -opt_injective_info :: { Located ([AddAnn], Maybe (LInjectivityAnn RdrName)) }+opt_injective_info :: { Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) } : {- empty -} { noLoc ([], Nothing) } | '|' injectivity_cond { sLL $1 $> ([mj AnnVbar $1] , Just ($2)) } -injectivity_cond :: { LInjectivityAnn RdrName }+injectivity_cond :: { LInjectivityAnn GhcPs } : tyvarid '->' inj_varids {% ams (sLL $1 $> (InjectivityAnn $1 (reverse (unLoc $3)))) [mu AnnRarrow $2] }@@ -1136,13 +1136,13 @@ -- Closed type families -where_type_family :: { Located ([AddAnn],FamilyInfo RdrName) }+where_type_family :: { Located ([AddAnn],FamilyInfo GhcPs) } : {- empty -} { noLoc ([],OpenTypeFamily) } | 'where' ty_fam_inst_eqn_list { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2) ,ClosedTypeFamily (fmap reverse $ snd $ unLoc $2)) } -ty_fam_inst_eqn_list :: { Located ([AddAnn],Maybe [LTyFamInstEqn RdrName]) }+ty_fam_inst_eqn_list :: { Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]) } : '{' ty_fam_inst_eqns '}' { sLL $1 $> ([moc $1,mcc $3] ,Just (unLoc $2)) } | vocurly ty_fam_inst_eqns close { let L loc _ = $2 in@@ -1152,23 +1152,25 @@ | vocurly '..' close { let L loc _ = $2 in L loc ([mj AnnDotdot $2],Nothing) } -ty_fam_inst_eqns :: { Located [LTyFamInstEqn RdrName] }+ty_fam_inst_eqns :: { Located [LTyFamInstEqn GhcPs] } : ty_fam_inst_eqns ';' ty_fam_inst_eqn- {% asl (unLoc $1) $2 (snd $ unLoc $3)- >> ams $3 (fst $ unLoc $3)- >> return (sLL $1 $> ((snd $ unLoc $3) : unLoc $1)) }+ {% let L loc (anns, eqn) = $3 in+ asl (unLoc $1) $2 (L loc eqn)+ >> ams $3 anns+ >> return (sLL $1 $> (L loc eqn : unLoc $1)) } | ty_fam_inst_eqns ';' {% addAnnotation (gl $1) AnnSemi (gl $2) >> return (sLL $1 $> (unLoc $1)) }- | ty_fam_inst_eqn {% ams $1 (fst $ unLoc $1)- >> return (sLL $1 $> [snd $ unLoc $1]) }+ | ty_fam_inst_eqn {% let L loc (anns, eqn) = $1 in+ ams $1 anns+ >> return (sLL $1 $> [L loc eqn]) } | {- empty -} { noLoc [] } -ty_fam_inst_eqn :: { Located ([AddAnn],LTyFamInstEqn RdrName) }+ty_fam_inst_eqn :: { Located ([AddAnn],TyFamInstEqn GhcPs) } : type '=' ctype -- Note the use of type for the head; this allows -- infix type constructors and type patterns {% do { (eqn,ann) <- mkTyFamInstEqn $1 $3- ; return (sLL $1 $> (mj AnnEqual $2:ann, sLL $1 $> eqn)) } }+ ; return (sLL $1 $> (mj AnnEqual $2:ann, eqn)) } } -- Associated type family declarations --@@ -1179,7 +1181,7 @@ -- declarations without a kind signature cause parsing conflicts with empty -- data declarations. ---at_decl_cls :: { LHsDecl RdrName }+at_decl_cls :: { LHsDecl GhcPs } : -- data family declarations, with optional 'family' keyword 'data' opt_family type opt_datafam_kind_sig {% amms (liftM mkTyClD (mkFamDecl (comb3 $1 $3 $4) DataFamily $3@@ -1215,25 +1217,37 @@ : {- empty -} { [] } | 'family' { [mj AnnFamily $1] } +opt_instance :: { [AddAnn] }+ : {- empty -} { [] }+ | 'instance' { [mj AnnInstance $1] }+ -- Associated type instances ---at_decl_inst :: { LInstDecl RdrName }- -- type instance declarations- : 'type' ty_fam_inst_eqn+at_decl_inst :: { LInstDecl GhcPs }+ -- type instance declarations, with optional 'instance' keyword+ : 'type' opt_instance ty_fam_inst_eqn -- Note the use of type for the head; this allows -- infix type constructors and type patterns- {% ams $2 (fst $ unLoc $2) >>- amms (mkTyFamInst (comb2 $1 $2) (snd $ unLoc $2))- (mj AnnType $1:(fst $ unLoc $2)) }+ {% ams $3 (fst $ unLoc $3) >>+ amms (mkTyFamInst (comb2 $1 $3) (snd $ unLoc $3))+ (mj AnnType $1:$2++(fst $ unLoc $3)) } - -- data/newtype instance declaration+ -- data/newtype instance declaration, with optional 'instance' keyword+ -- (can't use opt_instance because you get reduce/reduce errors) | data_or_newtype capi_ctype tycl_hdr constrs maybe_derivings {% amms (mkDataFamInst (comb4 $1 $3 $4 $5) (snd $ unLoc $1) $2 $3 Nothing (reverse (snd $ unLoc $4)) (fmap reverse $5)) ((fst $ unLoc $1):(fst $ unLoc $4)) } - -- GADT instance declaration+ | data_or_newtype 'instance' capi_ctype tycl_hdr constrs maybe_derivings+ {% amms (mkDataFamInst (comb4 $1 $4 $5 $6) (snd $ unLoc $1) $3 $4+ Nothing (reverse (snd $ unLoc $5))+ (fmap reverse $6))+ ((fst $ unLoc $1):mj AnnInstance $2:(fst $ unLoc $5)) }++ -- GADT instance declaration, with optional 'instance' keyword+ -- (can't use opt_instance because you get reduce/reduce errors) | data_or_newtype capi_ctype tycl_hdr opt_kind_sig gadt_constrlist maybe_derivings@@ -1242,27 +1256,35 @@ (fmap reverse $6)) ((fst $ unLoc $1):(fst $ unLoc $4)++(fst $ unLoc $5)) } + | data_or_newtype 'instance' capi_ctype tycl_hdr opt_kind_sig+ gadt_constrlist+ maybe_derivings+ {% amms (mkDataFamInst (comb4 $1 $4 $6 $7) (snd $ unLoc $1) $3+ $4 (snd $ unLoc $5) (snd $ unLoc $6)+ (fmap reverse $7))+ ((fst $ unLoc $1):mj AnnInstance $2:(fst $ unLoc $5)++(fst $ unLoc $6)) }+ data_or_newtype :: { Located (AddAnn, NewOrData) } : 'data' { sL1 $1 (mj AnnData $1,DataType) } | 'newtype' { sL1 $1 (mj AnnNewtype $1,NewType) } -- Family result/return kind signatures -opt_kind_sig :: { Located ([AddAnn], Maybe (LHsKind RdrName)) }+opt_kind_sig :: { Located ([AddAnn], Maybe (LHsKind GhcPs)) } : { noLoc ([] , Nothing) } | '::' kind { sLL $1 $> ([mu AnnDcolon $1], Just $2) } -opt_datafam_kind_sig :: { Located ([AddAnn], LFamilyResultSig RdrName) }+opt_datafam_kind_sig :: { Located ([AddAnn], LFamilyResultSig GhcPs) } : { noLoc ([] , noLoc NoSig )} | '::' kind { sLL $1 $> ([mu AnnDcolon $1], sLL $1 $> (KindSig $2))} -opt_tyfam_kind_sig :: { Located ([AddAnn], LFamilyResultSig RdrName) }+opt_tyfam_kind_sig :: { Located ([AddAnn], LFamilyResultSig GhcPs) } : { noLoc ([] , noLoc NoSig )} | '::' kind { sLL $1 $> ([mu AnnDcolon $1], sLL $1 $> (KindSig $2))} | '=' tv_bndr { sLL $1 $> ([mj AnnEqual $1] , sLL $1 $> (TyVarSig $2))} -opt_at_kind_inj_sig :: { Located ([AddAnn], ( LFamilyResultSig RdrName- , Maybe (LInjectivityAnn RdrName)))}+opt_at_kind_inj_sig :: { Located ([AddAnn], ( LFamilyResultSig GhcPs+ , Maybe (LInjectivityAnn GhcPs)))} : { noLoc ([], (noLoc NoSig, Nothing)) } | '::' kind { sLL $1 $> ( [mu AnnDcolon $1] , (sLL $2 $> (KindSig $2), Nothing)) }@@ -1277,7 +1299,7 @@ -- (Eq a, Ord b) => T a b -- T Int [a] -- for associated types -- Rather a lot of inlining here, else we get reduce/reduce errors-tycl_hdr :: { Located (Maybe (LHsContext RdrName), LHsType RdrName) }+tycl_hdr :: { Located (Maybe (LHsContext GhcPs), LHsType GhcPs) } : context '=>' type {% addAnnotation (gl $1) (toUnicodeAnn AnnDarrow $2) (gl $2) >> (return (sLL $1 $> (Just $1, $3))) }@@ -1299,7 +1321,7 @@ -- Stand-alone deriving -- Glasgow extension: stand-alone deriving declarations-stand_alone_deriving :: { LDerivDecl RdrName }+stand_alone_deriving :: { LDerivDecl GhcPs } : 'deriving' deriv_strategy 'instance' overlap_pragma inst_type {% do { let { err = text "in the stand-alone deriving instance" <> colon <+> quotes (ppr $5) }@@ -1309,7 +1331,7 @@ ----------------------------------------------------------------------------- -- Role annotations -role_annot :: { LRoleAnnotDecl RdrName }+role_annot :: { LRoleAnnotDecl GhcPs } role_annot : 'type' 'role' oqtycon maybe_roles {% amms (mkRoleAnnotDecl (comb3 $1 $3 $4) $3 (reverse (unLoc $4))) [mj AnnType $1,mj AnnRole $2] }@@ -1331,7 +1353,7 @@ -- Pattern synonyms -- Glasgow extension: pattern synonyms-pattern_synonym_decl :: { LHsDecl RdrName }+pattern_synonym_decl :: { LHsDecl GhcPs } : 'pattern' pattern_synonym_lhs '=' pat {% let (name, args,as ) = $2 in ams (sLL $1 $> . ValD $ mkPatSynBind name args $4@@ -1353,27 +1375,27 @@ }} pattern_synonym_lhs :: { (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]) }- : con vars0 { ($1, PrefixPatSyn $2, []) }- | varid conop varid { ($2, InfixPatSyn $1 $3, []) }- | con '{' cvars1 '}' { ($1, RecordPatSyn $3, [moc $2, mcc $4] ) }+ : con vars0 { ($1, PrefixCon $2, []) }+ | varid conop varid { ($2, InfixCon $1 $3, []) }+ | con '{' cvars1 '}' { ($1, RecCon $3, [moc $2, mcc $4] ) } vars0 :: { [Located RdrName] } : {- empty -} { [] } | varid vars0 { $1 : $2 } cvars1 :: { [RecordPatSynField (Located RdrName)] }- : varid { [RecordPatSynField $1 $1] }- | varid ',' cvars1 {% addAnnotation (getLoc $1) AnnComma (getLoc $2) >>+ : var { [RecordPatSynField $1 $1] }+ | var ',' cvars1 {% addAnnotation (getLoc $1) AnnComma (getLoc $2) >> return ((RecordPatSynField $1 $1) : $3 )} where_decls :: { Located ([AddAnn]- , Located (OrdList (LHsDecl RdrName))) }+ , Located (OrdList (LHsDecl GhcPs))) } : 'where' '{' decls '}' { sLL $1 $> ((mj AnnWhere $1:moc $2 :mcc $4:(fst $ unLoc $3)),sL1 $3 (snd $ unLoc $3)) } | 'where' vocurly decls close { L (comb2 $1 $3) ((mj AnnWhere $1:(fst $ unLoc $3)) ,sL1 $3 (snd $ unLoc $3)) } -pattern_synonym_sig :: { LSig RdrName }+pattern_synonym_sig :: { LSig GhcPs } : 'pattern' con_list '::' sigtypedoc {% ams (sLL $1 $> $ PatSynSig (unLoc $2) (mkLHsSigType $4)) [mj AnnPattern $1, mu AnnDcolon $3] }@@ -1383,7 +1405,7 @@ -- Declaration in class bodies ---decl_cls :: { LHsDecl RdrName }+decl_cls :: { LHsDecl GhcPs } decl_cls : at_decl_cls { $1 } | decl { $1 } @@ -1395,7 +1417,7 @@ ; ams (sLL $1 $> $ SigD $ ClassOpSig True [v] $ mkLHsSigType $4) [mj AnnDefault $1,mu AnnDcolon $3] } } -decls_cls :: { Located ([AddAnn],OrdList (LHsDecl RdrName)) } -- Reversed+decls_cls :: { Located ([AddAnn],OrdList (LHsDecl GhcPs)) } -- Reversed : decls_cls ';' decl_cls {% if isNilOL (snd $ unLoc $1) then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1) , unitOL $3))@@ -1412,7 +1434,7 @@ decllist_cls :: { Located ([AddAnn]- , OrdList (LHsDecl RdrName)) } -- Reversed+ , OrdList (LHsDecl GhcPs)) } -- Reversed : '{' decls_cls '}' { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2) ,snd $ unLoc $2) } | vocurly decls_cls close { $2 }@@ -1420,7 +1442,7 @@ -- Class body -- where_cls :: { Located ([AddAnn]- ,(OrdList (LHsDecl RdrName))) } -- Reversed+ ,(OrdList (LHsDecl GhcPs))) } -- Reversed -- No implicit parameters -- May have type declarations : 'where' decllist_cls { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)@@ -1429,11 +1451,11 @@ -- Declarations in instance bodies ---decl_inst :: { Located (OrdList (LHsDecl RdrName)) }+decl_inst :: { Located (OrdList (LHsDecl GhcPs)) } decl_inst : at_decl_inst { sLL $1 $> (unitOL (sL1 $1 (InstD (unLoc $1)))) } | decl { sLL $1 $> (unitOL $1) } -decls_inst :: { Located ([AddAnn],OrdList (LHsDecl RdrName)) } -- Reversed+decls_inst :: { Located ([AddAnn],OrdList (LHsDecl GhcPs)) } -- Reversed : decls_inst ';' decl_inst {% if isNilOL (snd $ unLoc $1) then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1) , unLoc $3))@@ -1451,14 +1473,14 @@ decllist_inst :: { Located ([AddAnn]- , OrdList (LHsDecl RdrName)) } -- Reversed+ , OrdList (LHsDecl GhcPs)) } -- Reversed : '{' decls_inst '}' { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2),snd $ unLoc $2) } | vocurly decls_inst close { L (gl $2) (unLoc $2) } -- Instance body -- where_inst :: { Located ([AddAnn]- , OrdList (LHsDecl RdrName)) } -- Reversed+ , OrdList (LHsDecl GhcPs)) } -- Reversed -- No implicit parameters -- May have type declarations : 'where' decllist_inst { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)@@ -1467,7 +1489,7 @@ -- Declarations in binding groups other than classes and instances ---decls :: { Located ([AddAnn],OrdList (LHsDecl RdrName)) }+decls :: { Located ([AddAnn],OrdList (LHsDecl GhcPs)) } : decls ';' decl {% if isNilOL (snd $ unLoc $1) then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1) , unitOL $3))@@ -1486,14 +1508,14 @@ | decl { sL1 $1 ([], unitOL $1) } | {- empty -} { noLoc ([],nilOL) } -decllist :: { Located ([AddAnn],Located (OrdList (LHsDecl RdrName))) }+decllist :: { Located ([AddAnn],Located (OrdList (LHsDecl GhcPs))) } : '{' decls '}' { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2) ,sL1 $2 $ snd $ unLoc $2) } | vocurly decls close { L (gl $2) (fst $ unLoc $2,sL1 $2 $ snd $ unLoc $2) } -- Binding groups other than those of class and instance declarations ---binds :: { Located ([AddAnn],Located (HsLocalBinds RdrName)) }+binds :: { Located ([AddAnn],Located (HsLocalBinds GhcPs)) } -- May have implicit parameters -- No type declarations : decllist {% do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc $1)@@ -1509,7 +1531,7 @@ emptyTcEvBinds)) } -wherebinds :: { Located ([AddAnn],Located (HsLocalBinds RdrName)) }+wherebinds :: { Located ([AddAnn],Located (HsLocalBinds GhcPs)) } -- May have implicit parameters -- No type declarations : 'where' binds { sLL $1 $> (mj AnnWhere $1 : (fst $ unLoc $2)@@ -1520,7 +1542,7 @@ ----------------------------------------------------------------------------- -- Transformation Rules -rules :: { OrdList (LRuleDecl RdrName) }+rules :: { OrdList (LRuleDecl GhcPs) } : rules ';' rule {% addAnnotation (oll $1) AnnSemi (gl $2) >> return ($1 `snocOL` $3) } | rules ';' {% addAnnotation (oll $1) AnnSemi (gl $2)@@ -1528,7 +1550,7 @@ | rule { unitOL $1 } | {- empty -} { nilOL } -rule :: { LRuleDecl RdrName }+rule :: { LRuleDecl GhcPs } : STRING rule_activation rule_forall infixexp '=' exp {%ams (sLL $1 $> $ (HsRule (L (gl $1) (getSTRINGs $1,getSTRING $1)) ((snd $2) `orElse` AlwaysActive)@@ -1544,21 +1566,21 @@ rule_explicit_activation :: { ([AddAnn] ,Activation) } -- In brackets : '[' INTEGER ']' { ([mos $1,mj AnnVal $2,mcs $3]- ,ActiveAfter (getINTEGERs $2) (fromInteger (getINTEGER $2))) }+ ,ActiveAfter (getINTEGERs $2) (fromInteger (il_value (getINTEGER $2)))) } | '[' '~' INTEGER ']' { ([mos $1,mj AnnTilde $2,mj AnnVal $3,mcs $4]- ,ActiveBefore (getINTEGERs $3) (fromInteger (getINTEGER $3))) }+ ,ActiveBefore (getINTEGERs $3) (fromInteger (il_value (getINTEGER $3)))) } | '[' '~' ']' { ([mos $1,mj AnnTilde $2,mcs $3] ,NeverActive) } -rule_forall :: { ([AddAnn],[LRuleBndr RdrName]) }+rule_forall :: { ([AddAnn],[LRuleBndr GhcPs]) } : 'forall' rule_var_list '.' { ([mu AnnForall $1,mj AnnDot $3],$2) } | {- empty -} { ([],[]) } -rule_var_list :: { [LRuleBndr RdrName] }+rule_var_list :: { [LRuleBndr GhcPs] } : rule_var { [$1] } | rule_var rule_var_list { $1 : $2 } -rule_var :: { LRuleBndr RdrName }+rule_var :: { LRuleBndr GhcPs } : varid { sLL $1 $> (RuleBndr $1) } | '(' varid '::' ctype ')' {% ams (sLL $1 $> (RuleBndrSig $2 (mkLHsSigWcType $4)))@@ -1567,7 +1589,7 @@ ----------------------------------------------------------------------------- -- Warnings and deprecations (c.f. rules) -warnings :: { OrdList (LWarnDecl RdrName) }+warnings :: { OrdList (LWarnDecl GhcPs) } : warnings ';' warning {% addAnnotation (oll $1) AnnSemi (gl $2) >> return ($1 `appOL` $3) } | warnings ';' {% addAnnotation (oll $1) AnnSemi (gl $2)@@ -1576,12 +1598,12 @@ | {- empty -} { nilOL } -- SUP: TEMPORARY HACK, not checking for `module Foo'-warning :: { OrdList (LWarnDecl RdrName) }+warning :: { OrdList (LWarnDecl GhcPs) } : namelist strings {% amsu (sLL $1 $> (Warning (unLoc $1) (WarningTxt (noLoc NoSourceText) $ snd $ unLoc $2))) (fst $ unLoc $2) } -deprecations :: { OrdList (LWarnDecl RdrName) }+deprecations :: { OrdList (LWarnDecl GhcPs) } : deprecations ';' deprecation {% addAnnotation (oll $1) AnnSemi (gl $2) >> return ($1 `appOL` $3) }@@ -1591,7 +1613,7 @@ | {- empty -} { nilOL } -- SUP: TEMPORARY HACK, not checking for `module Foo'-deprecation :: { OrdList (LWarnDecl RdrName) }+deprecation :: { OrdList (LWarnDecl GhcPs) } : namelist strings {% amsu (sLL $1 $> $ (Warning (unLoc $1) (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc $2))) (fst $ unLoc $2) }@@ -1609,7 +1631,7 @@ ----------------------------------------------------------------------------- -- Annotations-annotation :: { LHsDecl RdrName }+annotation :: { LHsDecl GhcPs } : '{-# ANN' name_var aexp '#-}' {% ams (sLL $1 $> (AnnD $ HsAnnotation (getANN_PRAGs $1) (ValueAnnProvenance $2) $3))@@ -1629,7 +1651,7 @@ ----------------------------------------------------------------------------- -- Foreign import and export declarations -fdecl :: { Located ([AddAnn],HsDecl RdrName) }+fdecl :: { Located ([AddAnn],HsDecl GhcPs) } fdecl : 'import' callconv safety fspec {% mkImport $2 $3 (snd $ unLoc $4) >>= \i -> return (sLL $1 $> (mj AnnImport $1 : (fst $ unLoc $4),i)) }@@ -1653,7 +1675,7 @@ | 'interruptible' { sLL $1 $> PlayInterruptible } fspec :: { Located ([AddAnn]- ,(Located StringLiteral, Located RdrName, LHsSigType RdrName)) }+ ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)) } : STRING var '::' sigtypedoc { sLL $1 $> ([mu AnnDcolon $3] ,(L (getLoc $1) (getStringLiteral $1), $2, mkLHsSigType $4)) }@@ -1666,22 +1688,18 @@ ----------------------------------------------------------------------------- -- Type signatures -opt_sig :: { ([AddAnn], Maybe (LHsType RdrName)) }+opt_sig :: { ([AddAnn], Maybe (LHsType GhcPs)) } : {- empty -} { ([],Nothing) } | '::' sigtype { ([mu AnnDcolon $1],Just $2) } -opt_asig :: { ([AddAnn],Maybe (LHsType RdrName)) }- : {- empty -} { ([],Nothing) }- | '::' atype { ([mu AnnDcolon $1],Just $2) }- opt_tyconsig :: { ([AddAnn], Maybe (Located RdrName)) } : {- empty -} { ([], Nothing) } | '::' gtycon { ([mu AnnDcolon $1], Just $2) } -sigtype :: { LHsType RdrName }+sigtype :: { LHsType GhcPs } : ctype { $1 } -sigtypedoc :: { LHsType RdrName }+sigtypedoc :: { LHsType GhcPs } : ctypedoc { $1 } @@ -1691,7 +1709,7 @@ >> return (sLL $1 $> ($3 : unLoc $1)) } | var { sL1 $1 [$1] } -sigtypes1 :: { (OrdList (LHsSigType RdrName)) }+sigtypes1 :: { (OrdList (LHsSigType GhcPs)) } : sigtype { unitOL (mkLHsSigType $1) } | sigtype ',' sigtypes1 {% addAnnotation (gl $1) AnnComma (gl $2) >> return (unitOL (mkLHsSigType $1) `appOL` $3) }@@ -1717,7 +1735,7 @@ | '{-# NOUNPACK' '#-}' { sLL $1 $> ([mo $1, mc $2], getNOUNPACK_PRAGs $1, SrcNoUnpack) } -- A ctype is a for-all type-ctype :: { LHsType RdrName }+ctype :: { LHsType GhcPs } : 'forall' tv_bndrs '.' ctype {% hintExplicitForall (getLoc $1) >> ams (sLL $1 $> $ HsForAllTy { hst_bndrs = $2@@ -1742,7 +1760,7 @@ -- If we allow comments on types here, it's not clear if the comment applies -- to 'field' or to 'Int'. So we must use `ctype` to describe the type. -ctypedoc :: { LHsType RdrName }+ctypedoc :: { LHsType GhcPs } : 'forall' tv_bndrs '.' ctypedoc {% hintExplicitForall (getLoc $1) >> ams (sLL $1 $> $ HsForAllTy { hst_bndrs = $2@@ -1768,7 +1786,7 @@ -- Thus for some reason we allow f :: a~b => blah -- but not f :: ?x::Int => blah -- See Note [Parsing ~]-context :: { LHsContext RdrName }+context :: { LHsContext GhcPs } : btype {% do { (anns,ctx) <- checkContext $1 ; if null (unLoc ctx) then addAnnotation (gl $1) AnnUnit (gl $1)@@ -1776,7 +1794,7 @@ ; ams ctx anns } } -context_no_ops :: { LHsContext RdrName }+context_no_ops :: { LHsContext GhcPs } : btype_no_ops {% do { ty <- splitTilde $1 ; (anns,ctx) <- checkContext ty ; if null (unLoc ctx)@@ -1801,14 +1819,14 @@ is connected to the first type too. -} -type :: { LHsType RdrName }+type :: { LHsType GhcPs } : btype { $1 } | btype '->' ctype {% ams $1 [mu AnnRarrow $2] -- See note [GADT decl discards annotations] >> ams (sLL $1 $> $ HsFunTy $1 $3) [mu AnnRarrow $2] } -typedoc :: { LHsType RdrName }+typedoc :: { LHsType GhcPs } : btype { $1 } | btype docprev { sLL $1 $> $ HsDocTy $1 $2 } | btype '->' ctypedoc {% ams (sLL $1 $> $ HsFunTy $1 $3)@@ -1819,7 +1837,7 @@ [mu AnnRarrow $3] } -- See Note [Parsing ~]-btype :: { LHsType RdrName }+btype :: { LHsType GhcPs } : tyapps {% splitTildeApps (reverse (unLoc $1)) >>= \ts -> return $ sL1 $1 $ HsAppsTy ts } @@ -1827,16 +1845,16 @@ -- in order to forbid the blasphemous -- > data Foo = Int :+ Char :* Bool -- See also Note [Parsing data constructors is hard] in RdrHsSyn-btype_no_ops :: { LHsType RdrName }+btype_no_ops :: { LHsType GhcPs } : btype_no_ops atype { sLL $1 $> $ HsAppTy $1 $2 } | atype { $1 } -tyapps :: { Located [LHsAppType RdrName] } -- NB: This list is reversed+tyapps :: { Located [LHsAppType GhcPs] } -- NB: This list is reversed : tyapp { sL1 $1 [$1] } | tyapps tyapp { sLL $1 $> $ $2 : (unLoc $1) } -- See Note [HsAppsTy] in HsTypes-tyapp :: { LHsAppType RdrName }+tyapp :: { LHsAppType GhcPs } : atype { sL1 $1 $ HsAppPrefix $1 } | qtyconop { sL1 $1 $ HsAppInfix $1 } | tyvarop { sL1 $1 $ HsAppInfix $1 }@@ -1845,7 +1863,7 @@ | SIMPLEQUOTE varop {% ams (sLL $1 $> $ HsAppInfix $2) [mj AnnSimpleQuote $1] } -atype :: { LHsType RdrName }+atype :: { LHsType GhcPs } : ntgtycon { sL1 $1 (HsTyVar NotPromoted $1) } -- Not including unit tuples | tyvar { sL1 $1 (HsTyVar NotPromoted $1) } -- (See Note [Unit tuples]) | strict_mark atype {% ams (sLL $1 $> (HsBangTy (snd $ unLoc $1) $2))@@ -1901,7 +1919,7 @@ placeHolderKind ($2 : $4)) [mos $1,mcs $5] } | INTEGER { sLL $1 $> $ HsTyLit $ HsNumTy (getINTEGERs $1)- (getINTEGER $1) }+ (il_value (getINTEGER $1)) } | STRING { sLL $1 $> $ HsTyLit $ HsStrTy (getSTRINGs $1) (getSTRING $1) } | '_' { sL1 $1 $ mkAnonWildCardTy }@@ -1909,35 +1927,35 @@ -- An inst_type is what occurs in the head of an instance decl -- e.g. (Foo a, Gaz b) => Wibble a b -- It's kept as a single type for convenience.-inst_type :: { LHsSigType RdrName }+inst_type :: { LHsSigType GhcPs } : sigtype { mkLHsSigType $1 } -deriv_types :: { [LHsSigType RdrName] }+deriv_types :: { [LHsSigType GhcPs] } : typedoc { [mkLHsSigType $1] } | typedoc ',' deriv_types {% addAnnotation (gl $1) AnnComma (gl $2) >> return (mkLHsSigType $1 : $3) } -comma_types0 :: { [LHsType RdrName] } -- Zero or more: ty,ty,ty+comma_types0 :: { [LHsType GhcPs] } -- Zero or more: ty,ty,ty : comma_types1 { $1 } | {- empty -} { [] } -comma_types1 :: { [LHsType RdrName] } -- One or more: ty,ty,ty+comma_types1 :: { [LHsType GhcPs] } -- One or more: ty,ty,ty : ctype { [$1] } | ctype ',' comma_types1 {% addAnnotation (gl $1) AnnComma (gl $2) >> return ($1 : $3) } -bar_types2 :: { [LHsType RdrName] } -- Two or more: ty|ty|ty+bar_types2 :: { [LHsType GhcPs] } -- Two or more: ty|ty|ty : ctype '|' ctype {% addAnnotation (gl $1) AnnVbar (gl $2) >> return [$1,$3] } | ctype '|' bar_types2 {% addAnnotation (gl $1) AnnVbar (gl $2) >> return ($1 : $3) } -tv_bndrs :: { [LHsTyVarBndr RdrName] }+tv_bndrs :: { [LHsTyVarBndr GhcPs] } : tv_bndr tv_bndrs { $1 : $2 } | {- empty -} { [] } -tv_bndr :: { LHsTyVarBndr RdrName }+tv_bndr :: { LHsTyVarBndr GhcPs } : tyvar { sL1 $1 (UserTyVar $1) } | '(' tyvar '::' kind ')' {% ams (sLL $1 $> (KindedTyVar $2 $4)) [mop $1,mu AnnDcolon $3@@ -1982,7 +2000,7 @@ ----------------------------------------------------------------------------- -- Kinds -kind :: { LHsKind RdrName }+kind :: { LHsKind GhcPs } : ctype { $1 } {- Note [Promotion]@@ -2011,7 +2029,7 @@ -- Datatype declarations gadt_constrlist :: { Located ([AddAnn]- ,[LConDecl RdrName]) } -- Returned in order+ ,[LConDecl GhcPs]) } -- Returned in order : 'where' '{' gadt_constrs '}' { L (comb2 $1 $3) ([mj AnnWhere $1 ,moc $2@@ -2022,7 +2040,7 @@ , unLoc $3) } | {- empty -} { noLoc ([],[]) } -gadt_constrs :: { Located [LConDecl RdrName] }+gadt_constrs :: { Located [LConDecl GhcPs] } : gadt_constr_with_doc ';' gadt_constrs {% addAnnotation (gl $1) AnnSemi (gl $2) >> return (L (comb2 $1 $3) ($1 : unLoc $3)) }@@ -2035,14 +2053,14 @@ -- D { x,y :: a } :: T a -- forall a. Eq a => D { x,y :: a } :: T a -gadt_constr_with_doc :: { LConDecl RdrName }+gadt_constr_with_doc :: { LConDecl GhcPs } gadt_constr_with_doc : maybe_docnext ';' gadt_constr {% return $ addConDoc $3 $1 } | gadt_constr {% return $1 } -gadt_constr :: { LConDecl RdrName }+gadt_constr :: { LConDecl GhcPs } -- see Note [Difference in parsing GADT and data constructors] -- Returns a list because of: C,D :: ty : con_list '::' sigtype@@ -2061,17 +2079,17 @@ allowed in usual data constructors, but not in GADTs). -} -constrs :: { Located ([AddAnn],[LConDecl RdrName]) }+constrs :: { Located ([AddAnn],[LConDecl GhcPs]) } : maybe_docnext '=' constrs1 { L (comb2 $2 $3) ([mj AnnEqual $2] ,addConDocs (unLoc $3) $1)} -constrs1 :: { Located [LConDecl RdrName] }+constrs1 :: { Located [LConDecl GhcPs] } : constrs1 maybe_docnext '|' maybe_docprev constr {% addAnnotation (gl $ head $ unLoc $1) AnnVbar (gl $3) >> return (sLL $1 $> (addConDoc $5 $2 : addConDocFirst (unLoc $1) $4)) } | constr { sL1 $1 [$1] } -constr :: { LConDecl RdrName }+constr :: { LConDecl GhcPs } : maybe_docnext forall context_no_ops '=>' constr_stuff maybe_docprev {% ams (let (con,details) = unLoc $5 in addConDoc (L (comb4 $2 $3 $4 $5) (mkConDeclH98 con@@ -2085,28 +2103,28 @@ ($1 `mplus` $4)) (fst $ unLoc $2) } -forall :: { Located ([AddAnn], Maybe [LHsTyVarBndr RdrName]) }+forall :: { Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]) } : 'forall' tv_bndrs '.' { sLL $1 $> ([mu AnnForall $1,mj AnnDot $3], Just $2) } | {- empty -} { noLoc ([], Nothing) } -constr_stuff :: { Located (Located RdrName, HsConDeclDetails RdrName) }+constr_stuff :: { Located (Located RdrName, HsConDeclDetails GhcPs) } -- See Note [Parsing data constructors is hard] in RdrHsSyn : btype_no_ops {% do { c <- splitCon $1 ; return $ sLL $1 $> c } } | btype_no_ops conop btype_no_ops {% do { ty <- splitTilde $1 ; return $ sLL $1 $> ($2, InfixCon ty $3) } } -fielddecls :: { [LConDeclField RdrName] }+fielddecls :: { [LConDeclField GhcPs] } : {- empty -} { [] } | fielddecls1 { $1 } -fielddecls1 :: { [LConDeclField RdrName] }+fielddecls1 :: { [LConDeclField GhcPs] } : fielddecl maybe_docnext ',' maybe_docprev fielddecls1 {% addAnnotation (gl $1) AnnComma (gl $3) >> return ((addFieldDoc $1 $4) : addFieldDocs $5 $2) } | fielddecl { [$1] } -fielddecl :: { LConDeclField RdrName }+fielddecl :: { LConDeclField GhcPs } -- A list because of f,g :: Int : maybe_docnext sig_vars '::' ctype maybe_docprev {% ams (L (comb2 $2 $4)@@ -2114,18 +2132,18 @@ [mu AnnDcolon $3] } -- Reversed!-maybe_derivings :: { HsDeriving RdrName }+maybe_derivings :: { HsDeriving GhcPs } : {- empty -} { noLoc [] } | derivings { $1 } -- A list of one or more deriving clauses at the end of a datatype-derivings :: { HsDeriving RdrName }+derivings :: { HsDeriving GhcPs } : derivings deriving { sLL $1 $> $ $2 : unLoc $1 } | deriving { sLL $1 $> [$1] } -- The outer Located is just to allow the caller to -- know the rightmost extremity of the 'deriving' clause-deriving :: { LHsDerivingClause RdrName }+deriving :: { LHsDerivingClause GhcPs } : 'deriving' deriv_strategy qtycondoc {% let { full_loc = comb2 $1 $> } in ams (L full_loc $ HsDerivingClause $2 $ L full_loc@@ -2169,7 +2187,7 @@ We can't tell whether to reduce var to qvar until after we've read the signatures. -} -docdecl :: { LHsDecl RdrName }+docdecl :: { LHsDecl GhcPs } : docdecld { sL1 $1 (DocD (unLoc $1)) } docdecld :: { LDocDecl }@@ -2178,7 +2196,7 @@ | docnamed { sL1 $1 (case (unLoc $1) of (n, doc) -> DocCommentNamed n doc) } | docsection { sL1 $1 (case (unLoc $1) of (n, doc) -> DocGroup n doc) } -decl_no_th :: { LHsDecl RdrName }+decl_no_th :: { LHsDecl GhcPs } : sigdecl { $1 } | '!' aexp rhs {% do { let { e = sLL $1 $2 (SectionR (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2)@@ -2188,7 +2206,7 @@ (ann, r) <- checkValDef empty SrcStrict e Nothing $3 ; -- Depending upon what the pattern looks like we might get either -- a FunBind or PatBind back from checkValDef. See Note- -- [Varieties of binding pattern matches]+ -- [FunBind vs PatBind] case r of { (FunBind n _ _ _ _) -> ams (L l ()) [mj AnnFunId n] >> return () ;@@ -2202,7 +2220,7 @@ let { l = comb2 $1 $> }; -- Depending upon what the pattern looks like we might get either -- a FunBind or PatBind back from checkValDef. See Note- -- [Varieties of binding pattern matches]+ -- [FunBind vs PatBind] case r of { (FunBind n _ _ _ _) -> ams (L l ()) (mj AnnFunId n:(fst $2)) >> return () ;@@ -2213,7 +2231,7 @@ | pattern_synonym_decl { $1 } | docdecl { $1 } -decl :: { LHsDecl RdrName }+decl :: { LHsDecl GhcPs } : decl_no_th { $1 } -- Why do we only allow naked declaration splices in top-level@@ -2221,7 +2239,7 @@ -- fails terribly with a panic in cvBindsAndSigs otherwise. | splice_exp { sLL $1 $> $ mkSpliceDecl $1 } -rhs :: { Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName)) }+rhs :: { Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)) } : '=' exp wherebinds { sL (comb3 $1 $2 $3) ((mj AnnEqual $1 : (fst $ unLoc $3)) ,GRHSs (unguardedRHS (comb3 $1 $2 $3) $2)@@ -2230,15 +2248,15 @@ ,GRHSs (reverse (unLoc $1)) (snd $ unLoc $2)) } -gdrhs :: { Located [LGRHS RdrName (LHsExpr RdrName)] }+gdrhs :: { Located [LGRHS GhcPs (LHsExpr GhcPs)] } : gdrhs gdrh { sLL $1 $> ($2 : unLoc $1) } | gdrh { sL1 $1 [$1] } -gdrh :: { LGRHS RdrName (LHsExpr RdrName) }+gdrh :: { LGRHS GhcPs (LHsExpr GhcPs) } : '|' guardquals '=' exp {% ams (sL (comb2 $1 $>) $ GRHS (unLoc $2) $4) [mj AnnVbar $1,mj AnnEqual $3] } -sigdecl :: { LHsDecl RdrName }+sigdecl :: { LHsDecl GhcPs } : -- See Note [Declaration/signature overlap] for why we need infixexp here infixexp_top '::' sigtypedoc@@ -2289,7 +2307,7 @@ | '{-# SPECIALISE' activation qvar '::' sigtypes1 '#-}' {% ams ( let inl_prag = mkInlinePragma (getSPEC_PRAGs $1)- (EmptyInlineSpec, FunLike) (snd $2)+ (NoUserInline, FunLike) (snd $2) in sLL $1 $> $ SigD (SpecSig $3 (fromOL $5) inl_prag)) (mo $1:mu AnnDcolon $4:mc $6:(fst $2)) } @@ -2315,15 +2333,15 @@ explicit_activation :: { ([AddAnn],Activation) } -- In brackets : '[' INTEGER ']' { ([mj AnnOpenS $1,mj AnnVal $2,mj AnnCloseS $3]- ,ActiveAfter (getINTEGERs $2) (fromInteger (getINTEGER $2))) }+ ,ActiveAfter (getINTEGERs $2) (fromInteger (il_value (getINTEGER $2)))) } | '[' '~' INTEGER ']' { ([mj AnnOpenS $1,mj AnnTilde $2,mj AnnVal $3 ,mj AnnCloseS $4]- ,ActiveBefore (getINTEGERs $3) (fromInteger (getINTEGER $3))) }+ ,ActiveBefore (getINTEGERs $3) (fromInteger (il_value (getINTEGER $3)))) } ----------------------------------------------------------------------------- -- Expressions -quasiquote :: { Located (HsSplice RdrName) }+quasiquote :: { Located (HsSplice GhcPs) } : TH_QUASIQUOTE { let { loc = getLoc $1 ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc $1 ; quoterId = mkUnqual varName quoter }@@ -2333,7 +2351,7 @@ ; quoterId = mkQual varName (qual, quoter) } in sL (getLoc $1) (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote) } -exp :: { LHsExpr RdrName }+exp :: { LHsExpr GhcPs } : infixexp '::' sigtype {% ams (sLL $1 $> $ ExprWithTySig $1 (mkLHsSigWcType $3)) [mu AnnDcolon $2] } | infixexp '-<' exp {% ams (sLL $1 $> $ HsArrApp $1 $3 placeHolderType@@ -2350,26 +2368,25 @@ [mu AnnRarrowtail $2] } | infixexp { $1 } -infixexp :: { LHsExpr RdrName }+infixexp :: { LHsExpr GhcPs } : exp10 { $1 } | infixexp qop exp10 {% ams (sLL $1 $> (OpApp $1 $2 placeHolderFixity $3)) [mj AnnVal $2] } -- AnnVal annotation for NPlusKPat, which discards the operator -infixexp_top :: { LHsExpr RdrName }+infixexp_top :: { LHsExpr GhcPs } : exp10_top { $1 } | infixexp_top qop exp10_top {% ams (sLL $1 $> (OpApp $1 $2 placeHolderFixity $3)) [mj AnnVal $2] } -exp10_top :: { LHsExpr RdrName }- : '\\' apat apats opt_asig '->' exp+exp10_top :: { LHsExpr GhcPs }+ : '\\' apat apats '->' exp {% ams (sLL $1 $> $ HsLam (mkMatchGroup FromSource [sLL $1 $> $ Match { m_ctxt = LambdaExpr , m_pats = $2:$3- , m_type = snd $4- , m_grhss = unguardedGRHSs $6 }]))- (mj AnnLam $1:mu AnnRarrow $5:(fst $4)) }+ , m_grhss = unguardedGRHSs $5 }]))+ [mj AnnLam $1, mu AnnRarrow $4] } | 'let' binds 'in' exp {% ams (sLL $1 $> $ HsLet (snd $ unLoc $2) $4) (mj AnnLet $1:mj AnnIn $3@@ -2422,7 +2439,7 @@ -- hdaume: core annotation | fexp { $1 } -exp10 :: { LHsExpr RdrName }+exp10 :: { LHsExpr GhcPs } : exp10_top { $1 } | scc_annot exp {% ams (sLL $1 $> $ HsSCC (snd $ fst $ unLoc $1) (snd $ unLoc $1) $2) (fst $ fst $ unLoc $1) }@@ -2451,11 +2468,11 @@ ,mj AnnVal $9,mc $10], getGENERATED_PRAGs $1) ,((getStringLiteral $2)- ,( fromInteger $ getINTEGER $3- , fromInteger $ getINTEGER $5+ ,( fromInteger $ il_value $ getINTEGER $3+ , fromInteger $ il_value $ getINTEGER $5 )- ,( fromInteger $ getINTEGER $7- , fromInteger $ getINTEGER $9+ ,( fromInteger $ il_value $ getINTEGER $7+ , fromInteger $ il_value $ getINTEGER $9 ) )) , (( getINTEGERs $3@@ -2466,7 +2483,7 @@ ))) } -fexp :: { LHsExpr RdrName }+fexp :: { LHsExpr GhcPs } : fexp aexp { sLL $1 $> $ HsApp $1 $2 } | fexp TYPEAPP atype {% ams (sLL $1 $> $ HsAppType $1 (mkHsWildCardBndrs $3)) [mj AnnAt $2] }@@ -2474,7 +2491,7 @@ [mj AnnStatic $1] } | aexp { $1 } -aexp :: { LHsExpr RdrName }+aexp :: { LHsExpr GhcPs } : qvar '@' aexp {% ams (sLL $1 $> $ EAsPat $1 $3) [mj AnnAt $2] } -- If you change the parsing, make sure to understand -- Note [Lexing type applications] in Lexer.x@@ -2482,14 +2499,14 @@ | '~' aexp {% ams (sLL $1 $> $ ELazyPat $2) [mj AnnTilde $1] } | aexp1 { $1 } -aexp1 :: { LHsExpr RdrName }+aexp1 :: { LHsExpr GhcPs } : aexp1 '{' fbinds '}' {% do { r <- mkRecConstrOrUpdate $1 (comb2 $2 $4) (snd $3) ; _ <- ams (sLL $1 $> ()) (moc $2:mcc $4:(fst $3)) ; checkRecordSyntax (sLL $1 $> r) }} | aexp2 { $1 } -aexp2 :: { LHsExpr RdrName }+aexp2 :: { LHsExpr GhcPs } : qvar { sL1 $1 (HsVar $! $1) } | qcon { sL1 $1 (HsVar $! $1) } | ipvar { sL1 $1 (HsIPVar $! unLoc $1) }@@ -2499,7 +2516,7 @@ -- into HsOverLit when -foverloaded-strings is on. -- | STRING { sL (getLoc $1) (HsOverLit $! mkHsIsString (getSTRINGs $1) -- (getSTRING $1) placeHolderType) }- | INTEGER { sL (getLoc $1) (HsOverLit $! mkHsIntegral (getINTEGERs $1)+ | INTEGER { sL (getLoc $1) (HsOverLit $! mkHsIntegral (getINTEGER $1) placeHolderType) } | RATIONAL { sL (getLoc $1) (HsOverLit $! mkHsFractional (getRATIONAL $1) placeHolderType) }@@ -2547,7 +2564,7 @@ Nothing (reverse $3)) [mu AnnOpenB $1,mu AnnCloseB $4] } -splice_exp :: { LHsExpr RdrName }+splice_exp :: { LHsExpr GhcPs } : TH_ID_SPLICE {% ams (sL1 $1 $ mkHsSpliceE HasDollar (sL1 $1 $ HsVar (sL1 $1 (mkUnqual varName (getTH_ID_SPLICE $1)))))@@ -2561,21 +2578,21 @@ | '$$(' exp ')' {% ams (sLL $1 $> $ mkHsSpliceTE HasParens $2) [mj AnnOpenPTE $1,mj AnnCloseP $3] } -cmdargs :: { [LHsCmdTop RdrName] }+cmdargs :: { [LHsCmdTop GhcPs] } : cmdargs acmd { $2 : $1 } | {- empty -} { [] } -acmd :: { LHsCmdTop RdrName }+acmd :: { LHsCmdTop GhcPs } : aexp2 {% checkCommand $1 >>= \ cmd -> return (sL1 $1 $ HsCmdTop cmd placeHolderType placeHolderType []) } -cvtopbody :: { ([AddAnn],[LHsDecl RdrName]) }+cvtopbody :: { ([AddAnn],[LHsDecl GhcPs]) } : '{' cvtopdecls0 '}' { ([mj AnnOpenC $1 ,mj AnnCloseC $3],$2) } | vocurly cvtopdecls0 close { ([],$2) } -cvtopdecls0 :: { [LHsDecl RdrName] }+cvtopdecls0 :: { [LHsDecl GhcPs] } : topdecls_semi { cvTopDecls $1 } | topdecls { cvTopDecls $1 } @@ -2585,7 +2602,7 @@ -- "texp" is short for tuple expressions: -- things that can appear unparenthesized as long as they're -- inside parens or delimitted by commas-texp :: { LHsExpr RdrName }+texp :: { LHsExpr GhcPs } : exp { $1 } -- Note [Parsing sections]@@ -2622,7 +2639,7 @@ { (mvbars (fst $1) ++ mvbars (fst $3), Sum (snd $1 + 1) (snd $1 + snd $3 + 1) $2) } -- Always starts with commas; always follows an expr-commas_tup_tail :: { (SrcSpan,[LHsTupArg RdrName]) }+commas_tup_tail :: { (SrcSpan,[LHsTupArg GhcPs]) } commas_tup_tail : commas tup_tail {% do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (tail $ fst $1) ; return (@@ -2630,7 +2647,7 @@ ,(map (\l -> L l missingTupArg) (tail $ fst $1)) ++ $2)) } } -- Always follows a comma-tup_tail :: { [LHsTupArg RdrName] }+tup_tail :: { [LHsTupArg GhcPs] } : texp commas_tup_tail {% addAnnotation (gl $1) AnnComma (fst $2) >> return ((L (gl $1) (Present $1)) : snd $2) } | texp { [L (gl $1) (Present $1)] }@@ -2641,7 +2658,7 @@ -- The rules below are little bit contorted to keep lexps left-recursive while -- avoiding another shift/reduce-conflict.-list :: { ([AddAnn],HsExpr RdrName) }+list :: { ([AddAnn],HsExpr GhcPs) } : texp { ([],ExplicitList placeHolderType Nothing [$1]) } | lexps { ([],ExplicitList placeHolderType Nothing (reverse (unLoc $1))) }@@ -2661,7 +2678,7 @@ return ([mj AnnVbar $2], mkHsComp ctxt (unLoc $3) $1) } -lexps :: { Located [LHsExpr RdrName] }+lexps :: { Located [LHsExpr GhcPs] } : lexps ',' texp {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2) >> return (sLL $1 $> (((:) $! $3) $! unLoc $1)) }@@ -2671,7 +2688,7 @@ ----------------------------------------------------------------------------- -- List Comprehensions -flattenedpquals :: { Located [LStmt RdrName (LHsExpr RdrName)] }+flattenedpquals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] } : pquals { case (unLoc $1) of [qs] -> sL1 $1 qs -- We just had one thing in our "parallel" list so@@ -2684,13 +2701,13 @@ -- we wrap them into as a ParStmt } -pquals :: { Located [[LStmt RdrName (LHsExpr RdrName)]] }+pquals :: { Located [[LStmt GhcPs (LHsExpr GhcPs)]] } : squals '|' pquals {% addAnnotation (gl $ head $ unLoc $1) AnnVbar (gl $2) >> return (sLL $1 $> (reverse (unLoc $1) : unLoc $3)) } | squals { L (getLoc $1) [reverse (unLoc $1)] } -squals :: { Located [LStmt RdrName (LHsExpr RdrName)] } -- In reverse order, because the last+squals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] } -- In reverse order, because the last -- one can "grab" the earlier ones : squals ',' transformqual {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2) >>@@ -2710,7 +2727,7 @@ -- consensus on the syntax, this feature is not being used until we -- get user demand. -transformqual :: { Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)] -> Stmt RdrName (LHsExpr RdrName)) }+transformqual :: { Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs)) } -- Function is applied to a list of stmts *in order* : 'then' exp { sLL $1 $> ([mj AnnThen $1], \ss -> (mkTransformStmt ss $2)) } | 'then' exp 'by' exp { sLL $1 $> ([mj AnnThen $1,mj AnnBy $3],\ss -> (mkTransformByStmt ss $2 $4)) }@@ -2733,7 +2750,7 @@ -- Moreover, we allow explicit arrays with no element (represented by the nil -- constructor in the list case). -parr :: { ([AddAnn],HsExpr RdrName) }+parr :: { ([AddAnn],HsExpr GhcPs) } : { ([],ExplicitPArr placeHolderType []) } | texp { ([],ExplicitPArr placeHolderType [$1]) } | lexps { ([],ExplicitPArr placeHolderType@@ -2751,10 +2768,10 @@ ----------------------------------------------------------------------------- -- Guards -guardquals :: { Located [LStmt RdrName (LHsExpr RdrName)] }+guardquals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] } : guardquals1 { L (getLoc $1) (reverse (unLoc $1)) } -guardquals1 :: { Located [LStmt RdrName (LHsExpr RdrName)] }+guardquals1 :: { Located [LStmt GhcPs (LHsExpr GhcPs)] } : guardquals1 ',' qual {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2) >> return (sLL $1 $> ($3 : unLoc $1)) }@@ -2763,7 +2780,7 @@ ----------------------------------------------------------------------------- -- Case alternatives -altslist :: { Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]) }+altslist :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) } : '{' alts '}' { sLL $1 $> ((moc $1:mcc $3:(fst $ unLoc $2)) ,(reverse (snd $ unLoc $2))) } | vocurly alts close { L (getLoc $2) (fst $ unLoc $2@@ -2771,12 +2788,12 @@ | '{' '}' { noLoc ([moc $1,mcc $2],[]) } | vocurly close { noLoc ([],[]) } -alts :: { Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]) }+alts :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) } : alts1 { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) } | ';' alts { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)) ,snd $ unLoc $2) } -alts1 :: { Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]) }+alts1 :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) } : alts1 ';' alt {% if null (snd $ unLoc $1) then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1) ,[$3]))@@ -2791,34 +2808,33 @@ >> return (sLL $1 $> ([],snd $ unLoc $1))) } | alt { sL1 $1 ([],[$1]) } -alt :: { LMatch RdrName (LHsExpr RdrName) }- : pat opt_asig alt_rhs {%ams (sLL $1 $> (Match { m_ctxt = CaseAlt- , m_pats = [$1]- , m_type = snd $2- , m_grhss = snd $ unLoc $3 }))- (fst $2 ++ (fst $ unLoc $3))}+alt :: { LMatch GhcPs (LHsExpr GhcPs) }+ : pat alt_rhs {%ams (sLL $1 $> (Match { m_ctxt = CaseAlt+ , m_pats = [$1]+ , m_grhss = snd $ unLoc $2 }))+ (fst $ unLoc $2)} -alt_rhs :: { Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName)) }+alt_rhs :: { Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)) } : ralt wherebinds { sLL $1 $> (fst $ unLoc $2, GRHSs (unLoc $1) (snd $ unLoc $2)) } -ralt :: { Located [LGRHS RdrName (LHsExpr RdrName)] }+ralt :: { Located [LGRHS GhcPs (LHsExpr GhcPs)] } : '->' exp {% ams (sLL $1 $> (unguardedRHS (comb2 $1 $2) $2)) [mu AnnRarrow $1] } | gdpats { sL1 $1 (reverse (unLoc $1)) } -gdpats :: { Located [LGRHS RdrName (LHsExpr RdrName)] }+gdpats :: { Located [LGRHS GhcPs (LHsExpr GhcPs)] } : gdpats gdpat { sLL $1 $> ($2 : unLoc $1) } | gdpat { sL1 $1 [$1] } -- layout for MultiWayIf doesn't begin with an open brace, because it's hard to -- generate the open brace in addition to the vertical bar in the lexer, and -- we don't need it.-ifgdpats :: { Located ([AddAnn],[LGRHS RdrName (LHsExpr RdrName)]) }+ifgdpats :: { Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)]) } : '{' gdpats '}' { sLL $1 $> ([moc $1,mcc $3],unLoc $2) } | gdpats close { sL1 $1 ([],unLoc $1) } -gdpat :: { LGRHS RdrName (LHsExpr RdrName) }+gdpat :: { LGRHS GhcPs (LHsExpr GhcPs) } : '|' guardquals '->' exp {% ams (sL (comb2 $1 $>) $ GRHS (unLoc $2) $4) [mj AnnVbar $1,mu AnnRarrow $3] }@@ -2827,13 +2843,13 @@ -- e.g. "!x" or "!(x,y)" or "C a b" etc -- Bangs inside are parsed as infix operator applications, so that -- we parse them right when bang-patterns are off-pat :: { LPat RdrName }+pat :: { LPat GhcPs } pat : exp {% checkPattern empty $1 } | '!' aexp {% amms (checkPattern empty (sLL $1 $> (SectionR (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2))) [mj AnnBang $1] } -bindpat :: { LPat RdrName }+bindpat :: { LPat GhcPs } bindpat : exp {% checkPattern (text "Possibly caused by a missing 'do'?") $1 } | '!' aexp {% amms (checkPattern@@ -2841,21 +2857,21 @@ (sLL $1 $> (SectionR (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2))) [mj AnnBang $1] } -apat :: { LPat RdrName }+apat :: { LPat GhcPs } apat : aexp {% checkPattern empty $1 } | '!' aexp {% amms (checkPattern empty (sLL $1 $> (SectionR (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2))) [mj AnnBang $1] } -apats :: { [LPat RdrName] }+apats :: { [LPat GhcPs] } : apat apats { $1 : $2 } | {- empty -} { [] } ----------------------------------------------------------------------------- -- Statement sequences -stmtlist :: { Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)]) }+stmtlist :: { Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)]) } : '{' stmts '}' { sLL $1 $> ((moc $1:mcc $3:(fst $ unLoc $2)) ,(reverse $ snd $ unLoc $2)) } -- AZ:performance of reverse? | vocurly stmts close { L (gl $2) (fst $ unLoc $2@@ -2867,7 +2883,7 @@ -- So we use BodyStmts throughout, and switch the last one over -- in ParseUtils.checkDo instead -stmts :: { Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)]) }+stmts :: { Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)]) } : stmts ';' stmt {% if null (snd $ unLoc $1) then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1) ,$3 : (snd $ unLoc $1)))@@ -2887,16 +2903,16 @@ -- For typing stmts at the GHCi prompt, where -- the input may consist of just comments.-maybe_stmt :: { Maybe (LStmt RdrName (LHsExpr RdrName)) }+maybe_stmt :: { Maybe (LStmt GhcPs (LHsExpr GhcPs)) } : stmt { Just $1 } | {- nothing -} { Nothing } -stmt :: { LStmt RdrName (LHsExpr RdrName) }+stmt :: { LStmt GhcPs (LHsExpr GhcPs) } : qual { $1 } | 'rec' stmtlist {% ams (sLL $1 $> $ mkRecStmt (snd $ unLoc $2)) (mj AnnRec $1:(fst $ unLoc $2)) } -qual :: { LStmt RdrName (LHsExpr RdrName) }+qual :: { LStmt GhcPs (LHsExpr GhcPs) } : bindpat '<-' exp {% ams (sLL $1 $> $ mkBindStmt $1 $3) [mu AnnLarrow $2] } | exp { sL1 $1 $ mkBodyStmt $1 }@@ -2906,18 +2922,18 @@ ----------------------------------------------------------------------------- -- Record Field Update/Construction -fbinds :: { ([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool)) }+fbinds :: { ([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool)) } : fbinds1 { $1 } | {- empty -} { ([],([], False)) } -fbinds1 :: { ([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool)) }+fbinds1 :: { ([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool)) } : fbind ',' fbinds1 {% addAnnotation (gl $1) AnnComma (gl $2) >> return (case $3 of (ma,(flds, dd)) -> (ma,($1 : flds, dd))) } | fbind { ([],([$1], False)) } | '..' { ([mj AnnDotdot $1],([], True)) } -fbind :: { LHsRecField RdrName (LHsExpr RdrName) }+fbind :: { LHsRecField GhcPs (LHsExpr GhcPs) } : qvar '=' texp {% ams (sLL $1 $> $ HsRecField (sL1 $1 $ mkFieldOcc $1) $3 False) [mj AnnEqual $2] } -- RHS is a 'texp', allowing view patterns (Trac #6038)@@ -2931,7 +2947,7 @@ ----------------------------------------------------------------------------- -- Implicit Parameter Bindings -dbinds :: { Located [LIPBind RdrName] }+dbinds :: { Located [LIPBind GhcPs] } : dbinds ';' dbind {% addAnnotation (gl $ last $ unLoc $1) AnnSemi (gl $2) >> return (let { this = $3; rest = unLoc $1 }@@ -2941,7 +2957,7 @@ | dbind { let this = $1 in this `seq` sL1 $1 [this] } -- | {- empty -} { [] } -dbind :: { LIPBind RdrName }+dbind :: { LIPBind GhcPs } dbind : ipvar '=' exp {% ams (sLL $1 $> (IPBind (Left $1) $3)) [mj AnnEqual $2] } @@ -3122,7 +3138,7 @@ : QCONID { sL1 $1 $! mkQual tcClsName (getQCONID $1) } | tycon { $1 } -qtycondoc :: { LHsType RdrName } -- Qualified or unqualified+qtycondoc :: { LHsType GhcPs } -- Qualified or unqualified : qtycon { sL1 $1 (HsTyVar NotPromoted $1) } | qtycon docprev { sLL $1 $> (HsDocTy (sL1 $1 (HsTyVar NotPromoted $1)) $2) } @@ -3156,17 +3172,21 @@ [mj AnnBackquote $1,mj AnnVal $2 ,mj AnnBackquote $3] } -qop :: { LHsExpr RdrName } -- used in sections+qop :: { LHsExpr GhcPs } -- used in sections : qvarop { sL1 $1 $ HsVar $1 } | qconop { sL1 $1 $ HsVar $1 }- | '`' '_' '`' {% ams (sLL $1 $> EWildPat)- [mj AnnBackquote $1,mj AnnVal $2- ,mj AnnBackquote $3] }+ | hole_op { $1 } -qopm :: { LHsExpr RdrName } -- used in sections+qopm :: { LHsExpr GhcPs } -- used in sections : qvaropm { sL1 $1 $ HsVar $1 } | qconop { sL1 $1 $ HsVar $1 }+ | hole_op { $1 } +hole_op :: { LHsExpr GhcPs } -- used in sections+hole_op : '`' '_' '`' {% ams (sLL $1 $> EWildPat)+ [mj AnnBackquote $1,mj AnnVal $2+ ,mj AnnBackquote $3] }+ qvarop :: { Located RdrName } : qvarsym { $1 } | '`' qvarid '`' {% ams (sLL $1 $> (unLoc $2))@@ -3310,20 +3330,20 @@ ----------------------------------------------------------------------------- -- Literals -literal :: { Located HsLit }- : CHAR { sL1 $1 $ HsChar (getCHARs $1) $ getCHAR $1 }- | STRING { sL1 $1 $ HsString (getSTRINGs $1)- $ getSTRING $1 }- | PRIMINTEGER { sL1 $1 $ HsIntPrim (getPRIMINTEGERs $1)- $ getPRIMINTEGER $1 }- | PRIMWORD { sL1 $1 $ HsWordPrim (getPRIMWORDs $1)- $ getPRIMWORD $1 }- | PRIMCHAR { sL1 $1 $ HsCharPrim (getPRIMCHARs $1)- $ getPRIMCHAR $1 }- | PRIMSTRING { sL1 $1 $ HsStringPrim (getPRIMSTRINGs $1)- $ getPRIMSTRING $1 }- | PRIMFLOAT { sL1 $1 $ HsFloatPrim $ getPRIMFLOAT $1 }- | PRIMDOUBLE { sL1 $1 $ HsDoublePrim $ getPRIMDOUBLE $1 }+literal :: { Located (HsLit GhcPs) }+ : CHAR { sL1 $1 $ HsChar (sst $ getCHARs $1) $ getCHAR $1 }+ | STRING { sL1 $1 $ HsString (sst $ getSTRINGs $1)+ $ getSTRING $1 }+ | PRIMINTEGER { sL1 $1 $ HsIntPrim (sst $ getPRIMINTEGERs $1)+ $ getPRIMINTEGER $1 }+ | PRIMWORD { sL1 $1 $ HsWordPrim (sst $ getPRIMWORDs $1)+ $ getPRIMWORD $1 }+ | PRIMCHAR { sL1 $1 $ HsCharPrim (sst $ getPRIMCHARs $1)+ $ getPRIMCHAR $1 }+ | PRIMSTRING { sL1 $1 $ HsStringPrim (sst $ getPRIMSTRINGs $1)+ $ getPRIMSTRING $1 }+ | PRIMFLOAT { sL1 $1 $ HsFloatPrim def $ getPRIMFLOAT $1 }+ | PRIMDOUBLE { sL1 $1 $ HsDoublePrim def $ getPRIMDOUBLE $1 } ----------------------------------------------------------------------------- -- Layout@@ -3402,7 +3422,7 @@ getLABELVARID (L _ (ITlabelvarid x)) = x getCHAR (L _ (ITchar _ x)) = x getSTRING (L _ (ITstring _ x)) = x-getINTEGER (L _ (ITinteger _ x)) = x+getINTEGER (L _ (ITinteger x)) = x getRATIONAL (L _ (ITrational x)) = x getPRIMCHAR (L _ (ITprimchar _ x)) = x getPRIMSTRING (L _ (ITprimstring _ x)) = x@@ -3422,9 +3442,9 @@ getDOCNAMED (L _ (ITdocCommentNamed x)) = x getDOCSECTION (L _ (ITdocSection n x)) = (n, x) +getINTEGERs (L _ (ITinteger (IL src _ _))) = src getCHARs (L _ (ITchar src _)) = src getSTRINGs (L _ (ITstring src _)) = src-getINTEGERs (L _ (ITinteger src _)) = src getPRIMCHARs (L _ (ITprimchar src _)) = src getPRIMSTRINGs (L _ (ITprimstring src _)) = src getPRIMINTEGERs (L _ (ITprimint src _)) = src@@ -3571,7 +3591,7 @@ text "Multi-way if-expressions need MultiWayIf turned on" -- Hint about if usage for beginners-hintIf :: SrcSpan -> String -> P (LHsExpr RdrName)+hintIf :: SrcSpan -> String -> P (LHsExpr GhcPs) hintIf span msg = do mwiEnabled <- liftM ((LangExt.MultiWayIf `extopt`) . options) getPState if mwiEnabled@@ -3720,4 +3740,7 @@ asl :: [Located a] -> Located b -> Located a -> P() asl [] (L ls _) (L l _) = addAnnotation l AnnSemi ls asl (x:_xs) (L ls _) _x = addAnnotation (getLoc x) AnnSemi ls++sst ::HasSourceText a => SourceText -> a+sst = setSourceText }
parser/RdrHsSyn.hs view
@@ -6,6 +6,7 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-} module RdrHsSyn ( mkHsOpApp,@@ -66,6 +67,8 @@ ) where +import GhcPrelude+ import HsSyn -- Lots of it import Class ( FunDep ) import TyCon ( TyCon, isTupleTyCon, tyConSingleDataCon_maybe )@@ -130,10 +133,10 @@ mkInstD (L loc d) = L loc (InstD d) mkClassDecl :: SrcSpan- -> Located (Maybe (LHsContext RdrName), LHsType RdrName)+ -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs) -> Located (a,[Located (FunDep (Located RdrName))])- -> OrdList (LHsDecl RdrName)- -> P (LTyClDecl RdrName)+ -> OrdList (LHsDecl GhcPs)+ -> P (LTyClDecl GhcPs) mkClassDecl loc (L _ (mcxt, tycl_hdr)) fds where_cls = do { (binds, sigs, ats, at_insts, _, docs) <- cvBindsAndSigs where_cls@@ -150,31 +153,31 @@ , tcdATs = ats, tcdATDefs = at_defs, tcdDocs = docs , tcdFVs = placeHolderNames })) } -mkATDefault :: LTyFamInstDecl RdrName- -> Either (SrcSpan, SDoc) (LTyFamDefltEqn RdrName)+mkATDefault :: LTyFamInstDecl GhcPs+ -> Either (SrcSpan, SDoc) (LTyFamDefltEqn GhcPs) -- Take a type-family instance declaration and turn it into -- a type-family default equation for a class declaration -- We parse things as the former and use this function to convert to the latter -- -- We use the Either monad because this also called -- from Convert.hs-mkATDefault (L loc (TyFamInstDecl { tfid_eqn = L _ e }))- | TyFamEqn { tfe_tycon = tc, tfe_pats = pats, tfe_fixity = fixity- , tfe_rhs = rhs } <- e- = do { tvs <- checkTyVars (text "default") equalsDots tc (hsib_body pats)- ; return (L loc (TyFamEqn { tfe_tycon = tc- , tfe_pats = tvs- , tfe_fixity = fixity- , tfe_rhs = rhs })) }+mkATDefault (L loc (TyFamInstDecl { tfid_eqn = HsIB { hsib_body = e }}))+ | FamEqn { feqn_tycon = tc, feqn_pats = pats, feqn_fixity = fixity+ , feqn_rhs = rhs } <- e+ = do { tvs <- checkTyVars (text "default") equalsDots tc pats+ ; return (L loc (FamEqn { feqn_tycon = tc+ , feqn_pats = tvs+ , feqn_fixity = fixity+ , feqn_rhs = rhs })) } mkTyData :: SrcSpan -> NewOrData -> Maybe (Located CType)- -> Located (Maybe (LHsContext RdrName), LHsType RdrName)- -> Maybe (LHsKind RdrName)- -> [LConDecl RdrName]- -> HsDeriving RdrName- -> P (LTyClDecl RdrName)+ -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)+ -> Maybe (LHsKind GhcPs)+ -> [LConDecl GhcPs]+ -> HsDeriving GhcPs+ -> P (LTyClDecl GhcPs) mkTyData loc new_or_data cType (L _ (mcxt, tycl_hdr)) ksig data_cons maybe_deriv = do { (tc, tparams, fixity, ann) <- checkTyClHdr False tycl_hdr ; mapM_ (\a -> a loc) ann -- Add any API Annotations to the top SrcSpan@@ -188,11 +191,11 @@ mkDataDefn :: NewOrData -> Maybe (Located CType)- -> Maybe (LHsContext RdrName)- -> Maybe (LHsKind RdrName)- -> [LConDecl RdrName]- -> HsDeriving RdrName- -> P (HsDataDefn RdrName)+ -> Maybe (LHsContext GhcPs)+ -> Maybe (LHsKind GhcPs)+ -> [LConDecl GhcPs]+ -> HsDeriving GhcPs+ -> P (HsDataDefn GhcPs) mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv = do { checkDatatypeContext mcxt ; let cxt = fromMaybe (noLoc []) mcxt@@ -204,9 +207,9 @@ mkTySynonym :: SrcSpan- -> LHsType RdrName -- LHS- -> LHsType RdrName -- RHS- -> P (LTyClDecl RdrName)+ -> LHsType GhcPs -- LHS+ -> LHsType GhcPs -- RHS+ -> P (LTyClDecl GhcPs) mkTySynonym loc lhs rhs = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs ; mapM_ (\a -> a loc) ann -- Add any API Annotations to the top SrcSpan@@ -215,48 +218,48 @@ , tcdFixity = fixity , tcdRhs = rhs, tcdFVs = placeHolderNames })) } -mkTyFamInstEqn :: LHsType RdrName- -> LHsType RdrName- -> P (TyFamInstEqn RdrName,[AddAnn])+mkTyFamInstEqn :: LHsType GhcPs+ -> LHsType GhcPs+ -> P (TyFamInstEqn GhcPs,[AddAnn]) mkTyFamInstEqn lhs rhs = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs- ; return (TyFamEqn { tfe_tycon = tc- , tfe_pats = mkHsImplicitBndrs tparams- , tfe_fixity = fixity- , tfe_rhs = rhs },+ ; return (mkHsImplicitBndrs+ (FamEqn { feqn_tycon = tc+ , feqn_pats = tparams+ , feqn_fixity = fixity+ , feqn_rhs = rhs }), ann) } mkDataFamInst :: SrcSpan -> NewOrData -> Maybe (Located CType)- -> Located (Maybe (LHsContext RdrName), LHsType RdrName)- -> Maybe (LHsKind RdrName)- -> [LConDecl RdrName]- -> HsDeriving RdrName- -> P (LInstDecl RdrName)+ -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)+ -> Maybe (LHsKind GhcPs)+ -> [LConDecl GhcPs]+ -> HsDeriving GhcPs+ -> P (LInstDecl GhcPs) mkDataFamInst loc new_or_data cType (L _ (mcxt, tycl_hdr)) ksig data_cons maybe_deriv = do { (tc, tparams, fixity, ann) <- checkTyClHdr False tycl_hdr ; mapM_ (\a -> a loc) ann -- Add any API Annotations to the top SrcSpan ; defn <- mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv- ; return (L loc (DataFamInstD (- DataFamInstDecl { dfid_tycon = tc- , dfid_pats = mkHsImplicitBndrs tparams- , dfid_fixity = fixity- , dfid_defn = defn, dfid_fvs = placeHolderNames }))) }+ ; return (L loc (DataFamInstD (DataFamInstDecl (mkHsImplicitBndrs+ (FamEqn { feqn_tycon = tc+ , feqn_pats = tparams+ , feqn_fixity = fixity+ , feqn_rhs = defn }))))) } mkTyFamInst :: SrcSpan- -> LTyFamInstEqn RdrName- -> P (LInstDecl RdrName)+ -> TyFamInstEqn GhcPs+ -> P (LInstDecl GhcPs) mkTyFamInst loc eqn- = return (L loc (TyFamInstD (TyFamInstDecl { tfid_eqn = eqn- , tfid_fvs = placeHolderNames })))+ = return (L loc (TyFamInstD (TyFamInstDecl eqn))) mkFamDecl :: SrcSpan- -> FamilyInfo RdrName- -> LHsType RdrName -- LHS- -> Located (FamilyResultSig RdrName) -- Optional result signature- -> Maybe (LInjectivityAnn RdrName) -- Injectivity annotation- -> P (LTyClDecl RdrName)+ -> FamilyInfo GhcPs+ -> LHsType GhcPs -- LHS+ -> Located (FamilyResultSig GhcPs) -- Optional result signature+ -> Maybe (LInjectivityAnn GhcPs) -- Injectivity annotation+ -> P (LTyClDecl GhcPs) mkFamDecl loc info lhs ksig injAnn = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs ; mapM_ (\a -> a loc) ann -- Add any API Annotations to the top SrcSpan@@ -272,7 +275,7 @@ OpenTypeFamily -> empty ClosedTypeFamily {} -> whereDots -mkSpliceDecl :: LHsExpr RdrName -> HsDecl RdrName+mkSpliceDecl :: LHsExpr GhcPs -> HsDecl GhcPs -- If the user wrote -- [pads| ... ] then return a QuasiQuoteD -- $(e) then return a SpliceD@@ -293,9 +296,9 @@ = SpliceD (SpliceDecl (L loc (mkUntypedSplice NoParens lexpr)) ImplicitSplice) mkRoleAnnotDecl :: SrcSpan- -> Located RdrName -- type being annotated+ -> Located RdrName -- type being annotated -> [Located (Maybe FastString)] -- roles- -> P (LRoleAnnotDecl RdrName)+ -> P (LRoleAnnotDecl GhcPs) mkRoleAnnotDecl loc tycon roles = do { roles' <- mapM parse_role roles ; return $ L loc $ RoleAnnotDecl tycon roles' }@@ -332,25 +335,25 @@ -- | Groups together bindings for a single function-cvTopDecls :: OrdList (LHsDecl RdrName) -> [LHsDecl RdrName]+cvTopDecls :: OrdList (LHsDecl GhcPs) -> [LHsDecl GhcPs] cvTopDecls decls = go (fromOL decls) where- go :: [LHsDecl RdrName] -> [LHsDecl RdrName]+ go :: [LHsDecl GhcPs] -> [LHsDecl GhcPs] go [] = [] go (L l (ValD b) : ds) = L l' (ValD b') : go ds' where (L l' b', ds') = getMonoBind (L l b) ds go (d : ds) = d : go ds -- Declaration list may only contain value bindings and signatures.-cvBindGroup :: OrdList (LHsDecl RdrName) -> P (HsValBinds RdrName)+cvBindGroup :: OrdList (LHsDecl GhcPs) -> P (HsValBinds GhcPs) cvBindGroup binding = do { (mbs, sigs, fam_ds, tfam_insts, dfam_insts, _) <- cvBindsAndSigs binding ; ASSERT( null fam_ds && null tfam_insts && null dfam_insts) return $ ValBindsIn mbs sigs } -cvBindsAndSigs :: OrdList (LHsDecl RdrName)- -> P (LHsBinds RdrName, [LSig RdrName], [LFamilyDecl RdrName]- , [LTyFamInstDecl RdrName], [LDataFamInstDecl RdrName], [LDocDecl])+cvBindsAndSigs :: OrdList (LHsDecl GhcPs)+ -> P (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs]+ , [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl]) -- Input decls contain just value bindings and signatures -- and in case of class or instance declarations also -- associated type declarations. They might also contain Haddock comments.@@ -385,8 +388,8 @@ ----------------------------------------------------------------------------- -- Group function bindings into equation groups -getMonoBind :: LHsBind RdrName -> [LHsDecl RdrName]- -> (LHsBind RdrName, [LHsDecl RdrName])+getMonoBind :: LHsBind GhcPs -> [LHsDecl GhcPs]+ -> (LHsBind GhcPs, [LHsDecl GhcPs]) -- Suppose (b',ds') = getMonoBind b ds -- ds is a list of parsed bindings -- b is a MonoBinds that has just been read off the front@@ -423,9 +426,9 @@ getMonoBind bind binds = (bind, binds) -has_args :: [LMatch RdrName (LHsExpr RdrName)] -> Bool-has_args [] = panic "RdrHsSyn:has_args"-has_args ((L _ (Match _ args _ _)) : _) = not (null args)+has_args :: [LMatch GhcPs (LHsExpr GhcPs)] -> Bool+has_args [] = panic "RdrHsSyn:has_args"+has_args ((L _ (Match { m_pats = args })) : _) = not (null args) -- Don't group together FunBinds if they have -- no arguments. This is necessary now that variable bindings -- with no arguments are now treated as FunBinds rather@@ -462,8 +465,8 @@ it (Trac #12051). -} -splitCon :: LHsType RdrName- -> P (Located RdrName, HsConDeclDetails RdrName)+splitCon :: LHsType GhcPs+ -> P (Located RdrName, HsConDeclDetails GhcPs) -- See Note [Parsing data constructors is hard] -- This gets given a "type" that should look like -- C Int Bool@@ -502,8 +505,8 @@ | otherwise = empty mkPatSynMatchGroup :: Located RdrName- -> Located (OrdList (LHsDecl RdrName))- -> P (MatchGroup RdrName (LHsExpr RdrName))+ -> Located (OrdList (LHsDecl GhcPs))+ -> P (MatchGroup GhcPs (LHsExpr GhcPs)) mkPatSynMatchGroup (L loc patsyn_name) (L _ decls) = do { matches <- mapM fromDecl (fromOL decls) ; when (null matches) (wrongNumberErr loc)@@ -513,10 +516,16 @@ do { unless (name == patsyn_name) $ wrongNameBindingErr loc decl ; match <- case details of- PrefixCon pats ->- return $ Match (FunRhs ln Prefix NoSrcStrict) pats Nothing rhs- InfixCon pat1 pat2 ->- return $ Match (FunRhs ln Infix NoSrcStrict) [pat1, pat2] Nothing rhs+ PrefixCon pats -> return $ Match { m_ctxt = ctxt, m_pats = pats+ , m_grhss = rhs }+ where+ ctxt = FunRhs { mc_fun = ln, mc_fixity = Prefix, mc_strictness = NoSrcStrict }++ InfixCon p1 p2 -> return $ Match { m_ctxt = ctxt, m_pats = [p1, p2]+ , m_grhss = rhs }+ where+ ctxt = FunRhs { mc_fun = ln, mc_fixity = Infix, mc_strictness = NoSrcStrict }+ RecCon{} -> recordPatSynErr loc pat ; return $ L loc match } fromDecl (L loc decl) = extraDeclErr loc decl@@ -536,15 +545,15 @@ text "pattern synonym 'where' clause cannot be empty" $$ text "In the pattern synonym declaration for: " <+> ppr (patsyn_name) -recordPatSynErr :: SrcSpan -> LPat RdrName -> P a+recordPatSynErr :: SrcSpan -> LPat GhcPs -> P a recordPatSynErr loc pat = parseErrorSDoc loc $ text "record syntax not supported for pattern synonym declarations:" $$ ppr pat -mkConDeclH98 :: Located RdrName -> Maybe [LHsTyVarBndr RdrName]- -> LHsContext RdrName -> HsConDeclDetails RdrName- -> ConDecl RdrName+mkConDeclH98 :: Located RdrName -> Maybe [LHsTyVarBndr GhcPs]+ -> LHsContext GhcPs -> HsConDeclDetails GhcPs+ -> ConDecl GhcPs mkConDeclH98 name mb_forall cxt details = ConDeclH98 { con_name = name@@ -556,8 +565,8 @@ , con_doc = Nothing } mkGadtDecl :: [Located RdrName]- -> LHsSigType RdrName -- Always a HsForAllTy- -> ConDecl RdrName+ -> LHsSigType GhcPs -- Always a HsForAllTy+ -> ConDecl GhcPs mkGadtDecl names ty = ConDeclGADT { con_names = names , con_type = ty , con_doc = Nothing }@@ -664,7 +673,8 @@ -- * For PrefixCon we keep all the args in the res_ty -- * For RecCon we do not -checkTyVarsP :: SDoc -> SDoc -> Located RdrName -> [LHsType RdrName] -> P (LHsQTyVars RdrName)+checkTyVarsP :: SDoc -> SDoc -> Located RdrName -> [LHsType GhcPs]+ -> P (LHsQTyVars GhcPs) -- Same as checkTyVars, but in the P monad checkTyVarsP pp_what equals_or_where tc tparms = eitherToP $ checkTyVars pp_what equals_or_where tc tparms@@ -674,8 +684,8 @@ eitherToP (Left (loc, doc)) = parseErrorSDoc loc doc eitherToP (Right thing) = return thing -checkTyVars :: SDoc -> SDoc -> Located RdrName -> [LHsType RdrName]- -> Either (SrcSpan, SDoc) (LHsQTyVars RdrName)+checkTyVars :: SDoc -> SDoc -> Located RdrName -> [LHsType GhcPs]+ -> Either (SrcSpan, SDoc) (LHsQTyVars GhcPs) -- Check whether the given list of type parameters are all type variables -- (possibly with a kind signature) -- We use the Either monad because it's also called (via mkATDefault) from@@ -708,7 +718,7 @@ whereDots = text "where ..." equalsDots = text "= ..." -checkDatatypeContext :: Maybe (LHsContext RdrName) -> P ()+checkDatatypeContext :: Maybe (LHsContext GhcPs) -> P () checkDatatypeContext Nothing = return () checkDatatypeContext (Just (L loc c)) = do allowed <- extension datatypeContextsEnabled@@ -728,10 +738,10 @@ checkTyClHdr :: Bool -- True <=> class header -- False <=> type header- -> LHsType RdrName- -> P (Located RdrName, -- the head symbol (type or class name)- [LHsType RdrName], -- parameters of head symbol- LexicalFixity, -- the declaration is in infix format+ -> LHsType GhcPs+ -> P (Located RdrName, -- the head symbol (type or class name)+ [LHsType GhcPs], -- parameters of head symbol+ LexicalFixity, -- the declaration is in infix format [AddAnn]) -- API Annotation for HsParTy when stripping parens -- Well-formedness check and decomposition of type and class heads. -- Decomposes T ty1 .. tyn into (T, [ty1, ..., tyn])@@ -753,9 +763,9 @@ = goL head (args ++ acc) ann fixity go _ (HsAppsTy [L _ (HsAppInfix (L loc star))]) [] ann fix- | occNameFS (rdrNameOcc star) == fsLit "*"+ | isStar star = return (L loc (nameRdrName starKindTyConName), [], fix, ann)- | occNameFS (rdrNameOcc star) == fsLit "★"+ | isUniStar star = return (L loc (nameRdrName unicodeStarKindTyConName), [], fix, ann) go l (HsTupleTy HsBoxedOrConstraintTuple ts) [] ann fix@@ -769,7 +779,7 @@ = parseErrorSDoc l (text "Malformed head of type or class declaration:" <+> ppr ty) -checkContext :: LHsType RdrName -> P ([AddAnn],LHsContext RdrName)+checkContext :: LHsType GhcPs -> P ([AddAnn],LHsContext GhcPs) checkContext (L l orig_t) = check [] (L l orig_t) where@@ -794,19 +804,21 @@ -- We parse patterns as expressions and check for valid patterns below, -- converting the expression into a pattern at the same time. -checkPattern :: SDoc -> LHsExpr RdrName -> P (LPat RdrName)+checkPattern :: SDoc -> LHsExpr GhcPs -> P (LPat GhcPs) checkPattern msg e = checkLPat msg e -checkPatterns :: SDoc -> [LHsExpr RdrName] -> P [LPat RdrName]+checkPatterns :: SDoc -> [LHsExpr GhcPs] -> P [LPat GhcPs] checkPatterns msg es = mapM (checkPattern msg) es -checkLPat :: SDoc -> LHsExpr RdrName -> P (LPat RdrName)+checkLPat :: SDoc -> LHsExpr GhcPs -> P (LPat GhcPs) checkLPat msg e@(L l _) = checkPat msg l e [] -checkPat :: SDoc -> SrcSpan -> LHsExpr RdrName -> [LPat RdrName]- -> P (LPat RdrName)-checkPat _ loc (L l (HsVar (L _ c))) args+checkPat :: SDoc -> SrcSpan -> LHsExpr GhcPs -> [LPat GhcPs]+ -> P (LPat GhcPs)+checkPat _ loc (L l e@(HsVar (L _ c))) args | isRdrDataCon c = return (L loc (ConPatIn (L l c) (PrefixCon args)))+ | not (null args) && patIsRec c =+ patFail (text "Perhaps you intended to use RecursiveDo") l e checkPat msg loc e args -- OK to let this happen even if bang-patterns -- are not enabled, because there is no valid -- non-bang-pattern parse of (C ! e)@@ -822,7 +834,7 @@ checkPat msg loc e _ = patFail msg loc (unLoc e) -checkAPat :: SDoc -> SrcSpan -> HsExpr RdrName -> P (Pat RdrName)+checkAPat :: SDoc -> SrcSpan -> HsExpr GhcPs -> P (Pat GhcPs) checkAPat msg loc e0 = do pState <- getPState let opts = options pState@@ -893,7 +905,7 @@ -> return (SplicePat s) _ -> patFail msg loc e0 -placeHolderPunRhs :: LHsExpr RdrName+placeHolderPunRhs :: LHsExpr GhcPs -- The RHS of a punned record field will be filled in by the renamer -- It's better not to make it an error, in case we want to print it when debugging placeHolderPunRhs = noLoc (HsVar (noLoc pun_RDR))@@ -903,38 +915,41 @@ bang_RDR = mkUnqual varName (fsLit "!") -- Hack pun_RDR = mkUnqual varName (fsLit "pun-right-hand-side") -checkPatField :: SDoc -> LHsRecField RdrName (LHsExpr RdrName)- -> P (LHsRecField RdrName (LPat RdrName))+checkPatField :: SDoc -> LHsRecField GhcPs (LHsExpr GhcPs)+ -> P (LHsRecField GhcPs (LPat GhcPs)) checkPatField msg (L l fld) = do p <- checkLPat msg (hsRecFieldArg fld) return (L l (fld { hsRecFieldArg = p })) -patFail :: SDoc -> SrcSpan -> HsExpr RdrName -> P a+patFail :: SDoc -> SrcSpan -> HsExpr GhcPs -> P a patFail msg loc e = parseErrorSDoc loc err where err = text "Parse error in pattern:" <+> ppr e $$ msg +patIsRec :: RdrName -> Bool+patIsRec e = e == mkUnqual varName (fsLit "rec") + --------------------------------------------------------------------------- -- Check Equation Syntax checkValDef :: SDoc -> SrcStrictness- -> LHsExpr RdrName- -> Maybe (LHsType RdrName)- -> Located (a,GRHSs RdrName (LHsExpr RdrName))- -> P ([AddAnn],HsBind RdrName)+ -> LHsExpr GhcPs+ -> Maybe (LHsType GhcPs)+ -> Located (a,GRHSs GhcPs (LHsExpr GhcPs))+ -> P ([AddAnn],HsBind GhcPs) checkValDef msg _strictness lhs (Just sig) grhss -- x :: ty = rhs parses as a *pattern* binding = checkPatBind msg (L (combineLocs lhs sig) (ExprWithTySig lhs (mkLHsSigWcType sig))) grhss -checkValDef msg strictness lhs opt_sig g@(L l (_,grhss))+checkValDef msg strictness lhs Nothing g@(L l (_,grhss)) = do { mb_fun <- isFunLhs lhs ; case mb_fun of Just (fun, is_infix, pats, ann) -> checkFunBind msg strictness ann (getLoc lhs)- fun is_infix pats opt_sig (L l grhss)+ fun is_infix pats (L l grhss) Nothing -> checkPatBind msg lhs g } checkFunBind :: SDoc@@ -943,25 +958,25 @@ -> SrcSpan -> Located RdrName -> LexicalFixity- -> [LHsExpr RdrName]- -> Maybe (LHsType RdrName)- -> Located (GRHSs RdrName (LHsExpr RdrName))- -> P ([AddAnn],HsBind RdrName)-checkFunBind msg strictness ann lhs_loc fun is_infix pats opt_sig (L rhs_span grhss)+ -> [LHsExpr GhcPs]+ -> Located (GRHSs GhcPs (LHsExpr GhcPs))+ -> P ([AddAnn],HsBind GhcPs)+checkFunBind msg strictness ann lhs_loc fun is_infix pats (L rhs_span grhss) = do ps <- checkPatterns msg pats let match_span = combineSrcSpans lhs_loc rhs_span -- Add back the annotations stripped from any HsPar values in the lhs -- mapM_ (\a -> a match_span) ann return (ann, makeFunBind fun- [L match_span (Match { m_ctxt = FunRhs fun is_infix strictness+ [L match_span (Match { m_ctxt = FunRhs { mc_fun = fun+ , mc_fixity = is_infix+ , mc_strictness = strictness } , m_pats = ps- , m_type = opt_sig , m_grhss = grhss })]) -- The span of the match covers the entire equation. -- That isn't quite right, but it'll do for now. -makeFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)]- -> HsBind RdrName+makeFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)]+ -> HsBind GhcPs -- Like HsUtils.mkFunBind, but we need to be able to set the fixity too makeFunBind fn ms = FunBind { fun_id = fn,@@ -971,15 +986,15 @@ fun_tick = [] } checkPatBind :: SDoc- -> LHsExpr RdrName- -> Located (a,GRHSs RdrName (LHsExpr RdrName))- -> P ([AddAnn],HsBind RdrName)+ -> LHsExpr GhcPs+ -> Located (a,GRHSs GhcPs (LHsExpr GhcPs))+ -> P ([AddAnn],HsBind GhcPs) checkPatBind msg lhs (L _ (_,grhss)) = do { lhs <- checkPattern msg lhs ; return ([],PatBind lhs grhss placeHolderType placeHolderNames ([],[])) } -checkValSigLhs :: LHsExpr RdrName -> P (Located RdrName)+checkValSigLhs :: LHsExpr GhcPs -> P (Located RdrName) checkValSigLhs (L _ (HsVar lrdr@(L _ v))) | isUnqual v , not (isDataOcc (rdrNameOcc v))@@ -1011,11 +1026,11 @@ pattern_RDR = mkUnqual varName (fsLit "pattern") -checkDoAndIfThenElse :: LHsExpr RdrName+checkDoAndIfThenElse :: LHsExpr GhcPs -> Bool- -> LHsExpr RdrName+ -> LHsExpr GhcPs -> Bool- -> LHsExpr RdrName+ -> LHsExpr GhcPs -> P () checkDoAndIfThenElse guardExpr semiThen thenExpr semiElse elseExpr | semiThen || semiElse@@ -1035,7 +1050,7 @@ -- The parser left-associates, so there should -- not be any OpApps inside the e's-splitBang :: LHsExpr RdrName -> Maybe (LHsExpr RdrName, [LHsExpr RdrName])+splitBang :: LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs]) -- Splits (f ! g a b) into (f, [(! g), a, b]) splitBang (L _ (OpApp l_arg bang@(L _ (HsVar (L _ op))) _ r_arg)) | op == bang_RDR = Just (l_arg, L l' (SectionR bang arg1) : argns)@@ -1046,8 +1061,8 @@ split_bang e es = (e,es) splitBang _ = Nothing -isFunLhs :: LHsExpr RdrName- -> P (Maybe (Located RdrName, LexicalFixity, [LHsExpr RdrName],[AddAnn]))+isFunLhs :: LHsExpr GhcPs+ -> P (Maybe (Located RdrName, LexicalFixity, [LHsExpr GhcPs],[AddAnn])) -- A variable binding is parsed as a FunBind. -- Just (fun, is_infix, arg_pats) if e is a function LHS --@@ -1068,7 +1083,7 @@ go (L l (HsPar e)) es@(_:_) ann = go e es (ann ++ mkParensApiAnn l) -- Things of the form `!x` are also FunBinds- -- See Note [Varieties of binding pattern matches]+ -- See Note [FunBind vs PatBind] go (L _ (SectionR (L _ (HsVar (L _ bang))) (L l (HsVar (L _ var))))) [] ann | bang == bang_RDR , not (isRdrDataCon var) = return (Just (L l var, Prefix, [], ann))@@ -1107,7 +1122,7 @@ -- | Transform btype_no_ops with strict_mark's into HsEqTy's -- (((~a) ~b) c) ~d ==> ((~a) ~ (b c)) ~ d-splitTilde :: LHsType RdrName -> P (LHsType RdrName)+splitTilde :: LHsType GhcPs -> P (LHsType GhcPs) splitTilde t = go t where go (L loc (HsAppTy t1 t2)) | L lo (HsBangTy (HsSrcBang NoSourceText NoSrcUnpack SrcLazy) t2')@@ -1132,7 +1147,7 @@ -- | Transform tyapps with strict_marks into uses of twiddle -- [~a, ~b, c, ~d] ==> (~a) ~ b c ~ d-splitTildeApps :: [LHsAppType RdrName] -> P [LHsAppType RdrName]+splitTildeApps :: [LHsAppType GhcPs] -> P [LHsAppType GhcPs] splitTildeApps [] = return [] splitTildeApps (t : rest) = do rest' <- concatMapM go rest@@ -1173,13 +1188,13 @@ -- We parse arrow syntax as expressions and check for valid syntax below, -- converting the expression into a pattern at the same time. -checkCommand :: LHsExpr RdrName -> P (LHsCmd RdrName)+checkCommand :: LHsExpr GhcPs -> P (LHsCmd GhcPs) checkCommand lc = locMap checkCmd lc locMap :: (SrcSpan -> a -> P b) -> Located a -> P (Located b) locMap f (L l a) = f l a >>= (\b -> return $ L l b) -checkCmd :: SrcSpan -> HsExpr RdrName -> P (HsCmd RdrName)+checkCmd :: SrcSpan -> HsExpr GhcPs -> P (HsCmd GhcPs) checkCmd _ (HsArrApp e1 e2 ptt haat b) = return $ HsCmdArrApp e1 e2 ptt haat b checkCmd _ (HsArrForm e mf args) =@@ -1211,10 +1226,10 @@ checkCmd l e = cmdFail l e -checkCmdLStmt :: ExprLStmt RdrName -> P (CmdLStmt RdrName)+checkCmdLStmt :: ExprLStmt GhcPs -> P (CmdLStmt GhcPs) checkCmdLStmt = locMap checkCmdStmt -checkCmdStmt :: SrcSpan -> ExprStmt RdrName -> P (CmdStmt RdrName)+checkCmdStmt :: SrcSpan -> ExprStmt GhcPs -> P (CmdStmt GhcPs) checkCmdStmt _ (LastStmt e s r) = checkCommand e >>= (\c -> return $ LastStmt c s r) checkCmdStmt _ (BindStmt pat e b f t) =@@ -1227,20 +1242,21 @@ return $ stmt { recS_stmts = ss } checkCmdStmt l stmt = cmdStmtFail l stmt -checkCmdMatchGroup :: MatchGroup RdrName (LHsExpr RdrName) -> P (MatchGroup RdrName (LHsCmd RdrName))+checkCmdMatchGroup :: MatchGroup GhcPs (LHsExpr GhcPs)+ -> P (MatchGroup GhcPs (LHsCmd GhcPs)) checkCmdMatchGroup mg@(MG { mg_alts = L l ms }) = do ms' <- mapM (locMap $ const convert) ms return $ mg { mg_alts = L l ms' }- where convert (Match mf pat mty grhss) = do+ where convert match@(Match { m_grhss = grhss }) = do grhss' <- checkCmdGRHSs grhss- return $ Match mf pat mty grhss'+ return $ match { m_grhss = grhss'} -checkCmdGRHSs :: GRHSs RdrName (LHsExpr RdrName) -> P (GRHSs RdrName (LHsCmd RdrName))+checkCmdGRHSs :: GRHSs GhcPs (LHsExpr GhcPs) -> P (GRHSs GhcPs (LHsCmd GhcPs)) checkCmdGRHSs (GRHSs grhss binds) = do grhss' <- mapM checkCmdGRHS grhss return $ GRHSs grhss' binds -checkCmdGRHS :: LGRHS RdrName (LHsExpr RdrName) -> P (LGRHS RdrName (LHsCmd RdrName))+checkCmdGRHS :: LGRHS GhcPs (LHsExpr GhcPs) -> P (LGRHS GhcPs (LHsCmd GhcPs)) checkCmdGRHS = locMap $ const convert where convert (GRHS stmts e) = do@@ -1249,9 +1265,9 @@ return $ GRHS {- cmdStmts -} stmts c -cmdFail :: SrcSpan -> HsExpr RdrName -> P a+cmdFail :: SrcSpan -> HsExpr GhcPs -> P a cmdFail loc e = parseErrorSDoc loc (text "Parse error in command:" <+> ppr e)-cmdStmtFail :: SrcSpan -> Stmt RdrName (LHsExpr RdrName) -> P a+cmdStmtFail :: SrcSpan -> Stmt GhcPs (LHsExpr GhcPs) -> P a cmdStmtFail loc e = parseErrorSDoc loc (text "Parse error in command statement:" <+> ppr e) @@ -1265,10 +1281,10 @@ = parseErrorSDoc l (text ("Precedence out of range: " ++ show i)) mkRecConstrOrUpdate- :: LHsExpr RdrName+ :: LHsExpr GhcPs -> SrcSpan- -> ([LHsRecField RdrName (LHsExpr RdrName)], Bool)- -> P (HsExpr RdrName)+ -> ([LHsRecField GhcPs (LHsExpr GhcPs)], Bool)+ -> P (HsExpr GhcPs) mkRecConstrOrUpdate (L l (HsVar (L _ c))) _ (fs,dd) | isRdrDataCon c@@ -1277,14 +1293,14 @@ | dd = parseErrorSDoc l (text "You cannot use `..' in a record update") | otherwise = return (mkRdrRecordUpd exp (map (fmap mk_rec_upd_field) fs)) -mkRdrRecordUpd :: LHsExpr RdrName -> [LHsRecUpdField RdrName] -> HsExpr RdrName+mkRdrRecordUpd :: LHsExpr GhcPs -> [LHsRecUpdField GhcPs] -> HsExpr GhcPs mkRdrRecordUpd exp flds = RecordUpd { rupd_expr = exp , rupd_flds = flds , rupd_cons = PlaceHolder, rupd_in_tys = PlaceHolder , rupd_out_tys = PlaceHolder, rupd_wrap = PlaceHolder } -mkRdrRecordCon :: Located RdrName -> HsRecordBinds RdrName -> HsExpr RdrName+mkRdrRecordCon :: Located RdrName -> HsRecordBinds GhcPs -> HsExpr GhcPs mkRdrRecordCon con flds = RecordCon { rcon_con_name = con, rcon_flds = flds , rcon_con_expr = noPostTcExpr, rcon_con_like = PlaceHolder }@@ -1293,7 +1309,7 @@ mk_rec_fields fs False = HsRecFields { rec_flds = fs, rec_dotdot = Nothing } mk_rec_fields fs True = HsRecFields { rec_flds = fs, rec_dotdot = Just (length fs) } -mk_rec_upd_field :: HsRecField RdrName (LHsExpr RdrName) -> HsRecUpdField RdrName+mk_rec_upd_field :: HsRecField GhcPs (LHsExpr GhcPs) -> HsRecUpdField GhcPs mk_rec_upd_field (HsRecField (L loc (FieldOcc rdr _)) arg pun) = HsRecField (L loc (Unambiguous rdr PlaceHolder)) arg pun @@ -1322,8 +1338,8 @@ -- mkImport :: Located CCallConv -> Located Safety- -> (Located StringLiteral, Located RdrName, LHsSigType RdrName)- -> P (HsDecl RdrName)+ -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs)+ -> P (HsDecl GhcPs) mkImport cconv safety (L loc (StringLiteral esrc entity), v, ty) = case cconv of L _ CCallConv -> mkCImport@@ -1422,8 +1438,8 @@ -- construct a foreign export declaration -- mkExport :: Located CCallConv- -> (Located StringLiteral, Located RdrName, LHsSigType RdrName)- -> P (HsDecl RdrName)+ -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs)+ -> P (HsDecl GhcPs) mkExport (L lc cconv) (L le (StringLiteral esrc entity), v, ty) = return $ ForD $ ForeignExport { fd_name = v, fd_sig_ty = ty@@ -1455,7 +1471,7 @@ | ImpExpQcType (Located RdrName) | ImpExpQcWildcard -mkModuleImpExp :: Located ImpExpQcSpec -> ImpExpSubSpec -> P (IE RdrName)+mkModuleImpExp :: Located ImpExpQcSpec -> ImpExpSubSpec -> P (IE GhcPs) mkModuleImpExp (L l specname) subs = case subs of ImpExpAbs@@ -1509,7 +1525,7 @@ else parseErrorSDoc (getLoc name) (text "Illegal keyword 'type' (use ExplicitNamespaces to enable)") -checkImportSpec :: Located [LIE RdrName] -> P (Located [LIE RdrName])+checkImportSpec :: Located [LIE GhcPs] -> P (Located [LIE GhcPs]) checkImportSpec ie@(L _ specs) = case [l | (L l (IEThingWith _ (IEWildcard _) _ _)) <- specs] of [] -> return ie@@ -1541,10 +1557,10 @@ parseErrorSDoc span s = failSpanMsgP span s data SumOrTuple- = Sum ConTag Arity (LHsExpr RdrName)- | Tuple [LHsTupArg RdrName]+ = Sum ConTag Arity (LHsExpr GhcPs)+ | Tuple [LHsTupArg GhcPs] -mkSumOrTuple :: Boxity -> SrcSpan -> SumOrTuple -> P (HsExpr RdrName)+mkSumOrTuple :: Boxity -> SrcSpan -> SumOrTuple -> P (HsExpr GhcPs) -- Tuple mkSumOrTuple boxity _ (Tuple es) = return (ExplicitTuple es boxity)@@ -1555,7 +1571,7 @@ mkSumOrTuple Boxed l (Sum alt arity (L _ e)) = parseErrorSDoc l (hang (text "Boxed sums not supported:") 2 (ppr_boxed_sum alt arity e)) where- ppr_boxed_sum :: ConTag -> Arity -> HsExpr RdrName -> SDoc+ ppr_boxed_sum :: ConTag -> Arity -> HsExpr GhcPs -> SDoc ppr_boxed_sum alt arity e = text "(" <+> ppr_bars (alt - 1) <+> ppr e <+> ppr_bars (arity - alt) <+> text ")"
parser/cutils.c view
@@ -9,7 +9,7 @@ #include <string.h> -#ifdef HAVE_UNISTD_H+#if defined(HAVE_UNISTD_H) #include <unistd.h> #endif
prelude/ForeignCall.hs view
@@ -18,6 +18,8 @@ Header(..), CType(..), ) where +import GhcPrelude+ import FastString import Binary import Outputable@@ -196,7 +198,7 @@ instance Outputable CCallSpec where ppr (CCallSpec fun cconv safety)- = hcat [ ifPprDebug callconv, ppr_fun fun ]+ = hcat [ whenPprDebug callconv, ppr_fun fun ] where callconv = text "{-" <> ppr cconv <> text "-}"
prelude/KnownUniques.hs view
@@ -26,6 +26,8 @@ #include "HsVersions.h" +import GhcPrelude+ import TysWiredIn import TyCon import DataCon
prelude/KnownUniques.hs-boot view
@@ -1,5 +1,6 @@ module KnownUniques where +import GhcPrelude import Unique import Name import BasicTypes
prelude/PrelInfo.hs view
@@ -21,6 +21,7 @@ -- * Known-key names isKnownKeyName, lookupKnownKeyName,+ lookupKnownNameInfo, -- ** Internal use -- | 'knownKeyNames' is exported to seed the original name cache only;@@ -45,6 +46,8 @@ #include "HsVersions.h" +import GhcPrelude+ import KnownUniques import Unique ( isValidKnownKeyUnique ) @@ -59,6 +62,7 @@ import Name import NameEnv import MkId+import Outputable import TysPrim import TysWiredIn import HscTypes@@ -66,7 +70,6 @@ import TyCon import UniqFM import Util-import Panic import {-# SOURCE #-} TcTypeNats ( typeNatTyCons ) import Control.Applicative ((<|>))@@ -170,7 +173,7 @@ where namesEnv = foldl (\m n -> extendNameEnv_Acc (:) singleton m n n) emptyUFM all_names- badNamesEnv = filterNameEnv (\ns -> length ns > 1) namesEnv+ badNamesEnv = filterNameEnv (\ns -> ns `lengthExceeds` 1) namesEnv badNamesPairs = nonDetUFMToList badNamesEnv -- It's OK to use nonDetUFMToList here because the ordering only affects -- the message when we get a panic@@ -196,6 +199,22 @@ knownKeysMap :: UniqFM Name knownKeysMap = listToUFM [ (nameUnique n, n) | n <- knownKeyNames ]++-- | Given a 'Unique' lookup any associated arbitrary SDoc's to be displayed by+-- GHCi's ':info' command.+lookupKnownNameInfo :: Name -> SDoc+lookupKnownNameInfo name = case lookupNameEnv knownNamesInfo name of+ -- If we do find a doc, we add comment delimeters to make the output+ -- of ':info' valid Haskell.+ Nothing -> empty+ Just doc -> vcat [text "{-", doc, text "-}"]++-- A map from Uniques to SDocs, used in GHCi's ':info' command. (#12390)+knownNamesInfo :: NameEnv SDoc+knownNamesInfo = unitNameEnv coercibleTyConName $+ vcat [ text "Coercible is a special constraint with custom solving rules."+ , text "It is not a class."+ , text "Please see section 9.14.4 of the user's guide for details." ] {- We let a lot of "non-standard" values be visible, so that we can make
prelude/PrelNames.hs view
@@ -24,7 +24,7 @@ One of these Names contains (a) the module and occurrence name of the thing (b) its Unique- The may way the compiler "knows about" one of these things is+ The way the compiler "knows about" one of these things is where the type checker or desugarer needs to look it up. For example, when desugaring list comprehensions the desugarer needs to conjure up 'foldr'. It does this by looking up@@ -128,6 +128,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Module import OccName import RdrName@@ -238,6 +240,7 @@ typeLitSymbolDataConName, typeLitNatDataConName, typeRepIdName,+ mkTrTypeName, mkTrConName, mkTrAppName, mkTrFunName,@@ -330,7 +333,7 @@ otherwiseIdName, inlineIdName, eqStringName, assertName, breakpointName, breakpointCondName, breakpointAutoName, opaqueTyConName,- assertErrorName,+ assertErrorName, traceName, printName, fstName, sndName, -- Integer@@ -471,7 +474,7 @@ gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_GHCI, gHC_CSTRING, gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER_TYPE, gHC_NATURAL, gHC_LIST, gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING,- dATA_FOLDABLE, dATA_TRAVERSABLE, dATA_MONOID, dATA_SEMIGROUP,+ dATA_FOLDABLE, dATA_TRAVERSABLE, gHC_CONC, gHC_IO, gHC_IO_Exception, gHC_ST, gHC_ARR, gHC_STABLE, gHC_PTR, gHC_ERR, gHC_REAL, gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC,@@ -479,7 +482,7 @@ rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_ZIP, mONAD_FAIL, aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION_BASE, gHC_TYPELITS, gHC_TYPENATS, dATA_TYPE_EQUALITY,- dATA_COERCE :: Module+ dATA_COERCE, dEBUG_TRACE :: Module gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values gHC_TYPES = mkPrimModule (fsLit "GHC.Types")@@ -502,8 +505,6 @@ dATA_STRING = mkBaseModule (fsLit "Data.String") dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable") dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")-dATA_SEMIGROUP = mkBaseModule (fsLit "Data.Semigroup")-dATA_MONOID = mkBaseModule (fsLit "Data.Monoid") gHC_CONC = mkBaseModule (fsLit "GHC.Conc") gHC_IO = mkBaseModule (fsLit "GHC.IO") gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")@@ -539,6 +540,7 @@ gHC_TYPENATS = mkBaseModule (fsLit "GHC.TypeNats") dATA_TYPE_EQUALITY = mkBaseModule (fsLit "Data.Type.Equality") dATA_COERCE = mkBaseModule (fsLit "Data.Coerce")+dEBUG_TRACE = mkBaseModule (fsLit "Debug.Trace") gHC_PARR' :: Module gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")@@ -622,11 +624,10 @@ forall_tv_RDR = mkUnqual tvName (fsLit "forall") dot_tv_RDR = mkUnqual tvName (fsLit ".") -eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,+eq_RDR, ge_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR, ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName eq_RDR = nameRdrName eqName ge_RDR = nameRdrName geName-ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=") le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=") lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<") gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")@@ -743,6 +744,10 @@ lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP") expectP_RDR = varQual_RDR gHC_READ (fsLit "expectP") +readField_RDR, readSymField_RDR :: RdrName+readField_RDR = varQual_RDR gHC_READ (fsLit "readField")+readSymField_RDR = varQual_RDR gHC_READ (fsLit "readSymField")+ punc_RDR, ident_RDR, symbol_RDR :: RdrName punc_RDR = dataQual_RDR lEX (fsLit "Punc") ident_RDR = dataQual_RDR lEX (fsLit "Ident")@@ -755,10 +760,8 @@ prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec") pfail_RDR = varQual_RDR rEAD_PREC (fsLit "pfail") -showList_RDR, showList___RDR, showsPrec_RDR, shows_RDR, showString_RDR,+showsPrec_RDR, shows_RDR, showString_RDR, showSpace_RDR, showCommaSpace_RDR, showParen_RDR :: RdrName-showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")-showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__") showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec") shows_RDR = varQual_RDR gHC_SHOW (fsLit "shows") showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")@@ -839,7 +842,8 @@ uWordHash_RDR = varQual_RDR gHC_GENERICS (fsLit "uWord#") fmap_RDR, replace_RDR, pure_RDR, ap_RDR, liftA2_RDR, foldable_foldr_RDR,- foldMap_RDR, traverse_RDR, mempty_RDR, mappend_RDR :: RdrName+ foldMap_RDR, null_RDR, all_RDR, traverse_RDR, mempty_RDR,+ mappend_RDR :: RdrName fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap") replace_RDR = varQual_RDR gHC_BASE (fsLit "<$") pure_RDR = nameRdrName pureAName@@ -847,6 +851,8 @@ liftA2_RDR = varQual_RDR gHC_BASE (fsLit "liftA2") foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr") foldMap_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldMap")+null_RDR = varQual_RDR dATA_FOLDABLE (fsLit "null")+all_RDR = varQual_RDR dATA_FOLDABLE (fsLit "all") traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse") mempty_RDR = varQual_RDR gHC_BASE (fsLit "mempty") mappend_RDR = varQual_RDR gHC_BASE (fsLit "mappend")@@ -1020,8 +1026,8 @@ -- Classes (Semigroup, Monoid) semigroupClassName, sappendName :: Name-semigroupClassName = clsQual dATA_SEMIGROUP (fsLit "Semigroup") semigroupClassKey-sappendName = varQual dATA_SEMIGROUP (fsLit "<>") sappendClassOpKey+semigroupClassName = clsQual gHC_BASE (fsLit "Semigroup") semigroupClassKey+sappendName = varQual gHC_BASE (fsLit "<>") sappendClassOpKey monoidClassName, memptyName, mappendName, mconcatName :: Name monoidClassName = clsQual gHC_BASE (fsLit "Monoid") monoidClassKey memptyName = varQual gHC_BASE (fsLit "mempty") memptyClassOpKey@@ -1251,6 +1257,7 @@ , typeRepTyConName , someTypeRepTyConName , someTypeRepDataConName+ , mkTrTypeName , mkTrConName , mkTrAppName , mkTrFunName@@ -1264,6 +1271,7 @@ someTypeRepTyConName = tcQual tYPEABLE_INTERNAL (fsLit "SomeTypeRep") someTypeRepTyConKey someTypeRepDataConName = dcQual tYPEABLE_INTERNAL (fsLit "SomeTypeRep") someTypeRepDataConKey typeRepIdName = varQual tYPEABLE_INTERNAL (fsLit "typeRep#") typeRepIdKey+mkTrTypeName = varQual tYPEABLE_INTERNAL (fsLit "mkTrType") mkTrTypeKey mkTrConName = varQual tYPEABLE_INTERNAL (fsLit "mkTrCon") mkTrConKey mkTrAppName = varQual tYPEABLE_INTERNAL (fsLit "mkTrApp") mkTrAppKey mkTrFunName = varQual tYPEABLE_INTERNAL (fsLit "mkTrFun") mkTrFunKey@@ -1316,6 +1324,10 @@ assertErrorName :: Name assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey +-- Debug.Trace+traceName :: Name+traceName = varQual dEBUG_TRACE (fsLit "trace") traceKey+ -- Enum module (Enum, Bounded) enumClassName, enumFromName, enumFromToName, enumFromThenName, enumFromThenToName, boundedClassName :: Name@@ -1816,6 +1828,9 @@ typeNatAddTyFamNameKey, typeNatMulTyFamNameKey, typeNatExpTyFamNameKey, typeNatLeqTyFamNameKey, typeNatSubTyFamNameKey , typeSymbolCmpTyFamNameKey, typeNatCmpTyFamNameKey+ , typeNatDivTyFamNameKey+ , typeNatModTyFamNameKey+ , typeNatLogTyFamNameKey :: Unique typeNatKindConNameKey = mkPreludeTyConUnique 164 typeSymbolKindConNameKey = mkPreludeTyConUnique 165@@ -1826,48 +1841,51 @@ typeNatSubTyFamNameKey = mkPreludeTyConUnique 170 typeSymbolCmpTyFamNameKey = mkPreludeTyConUnique 171 typeNatCmpTyFamNameKey = mkPreludeTyConUnique 172+typeNatDivTyFamNameKey = mkPreludeTyConUnique 173+typeNatModTyFamNameKey = mkPreludeTyConUnique 174+typeNatLogTyFamNameKey = mkPreludeTyConUnique 175 -- Custom user type-errors errorMessageTypeErrorFamKey :: Unique-errorMessageTypeErrorFamKey = mkPreludeTyConUnique 173+errorMessageTypeErrorFamKey = mkPreludeTyConUnique 176 ntTyConKey:: Unique-ntTyConKey = mkPreludeTyConUnique 174+ntTyConKey = mkPreludeTyConUnique 177 coercibleTyConKey :: Unique-coercibleTyConKey = mkPreludeTyConUnique 175+coercibleTyConKey = mkPreludeTyConUnique 178 proxyPrimTyConKey :: Unique-proxyPrimTyConKey = mkPreludeTyConUnique 176+proxyPrimTyConKey = mkPreludeTyConUnique 179 specTyConKey :: Unique-specTyConKey = mkPreludeTyConUnique 177+specTyConKey = mkPreludeTyConUnique 180 anyTyConKey :: Unique-anyTyConKey = mkPreludeTyConUnique 178+anyTyConKey = mkPreludeTyConUnique 181 -smallArrayPrimTyConKey = mkPreludeTyConUnique 179-smallMutableArrayPrimTyConKey = mkPreludeTyConUnique 180+smallArrayPrimTyConKey = mkPreludeTyConUnique 182+smallMutableArrayPrimTyConKey = mkPreludeTyConUnique 183 staticPtrTyConKey :: Unique-staticPtrTyConKey = mkPreludeTyConUnique 181+staticPtrTyConKey = mkPreludeTyConUnique 184 staticPtrInfoTyConKey :: Unique-staticPtrInfoTyConKey = mkPreludeTyConUnique 182+staticPtrInfoTyConKey = mkPreludeTyConUnique 185 callStackTyConKey :: Unique-callStackTyConKey = mkPreludeTyConUnique 183+callStackTyConKey = mkPreludeTyConUnique 186 -- Typeables typeRepTyConKey, someTypeRepTyConKey, someTypeRepDataConKey :: Unique-typeRepTyConKey = mkPreludeTyConUnique 184-someTypeRepTyConKey = mkPreludeTyConUnique 185-someTypeRepDataConKey = mkPreludeTyConUnique 186+typeRepTyConKey = mkPreludeTyConUnique 187+someTypeRepTyConKey = mkPreludeTyConUnique 188+someTypeRepDataConKey = mkPreludeTyConUnique 189 typeSymbolAppendFamNameKey :: Unique-typeSymbolAppendFamNameKey = mkPreludeTyConUnique 187+typeSymbolAppendFamNameKey = mkPreludeTyConUnique 190 ---------------- Template Haskell ------------------- -- THNames.hs: USES TyConUniques 200-299@@ -2175,6 +2193,9 @@ oneShotKey = mkPreludeMiscIdUnique 106 runRWKey = mkPreludeMiscIdUnique 107 +traceKey :: Unique+traceKey = mkPreludeMiscIdUnique 108+ breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey, breakpointJumpIdKey, breakpointCondJumpIdKey, breakpointAutoJumpIdKey :: Unique@@ -2311,6 +2332,7 @@ -- Used to make `Typeable` dictionaries mkTyConKey+ , mkTrTypeKey , mkTrConKey , mkTrAppKey , mkTrFunKey@@ -2319,12 +2341,13 @@ , typeRepIdKey :: Unique mkTyConKey = mkPreludeMiscIdUnique 503-mkTrConKey = mkPreludeMiscIdUnique 504-mkTrAppKey = mkPreludeMiscIdUnique 505-typeNatTypeRepKey = mkPreludeMiscIdUnique 506-typeSymbolTypeRepKey = mkPreludeMiscIdUnique 507-typeRepIdKey = mkPreludeMiscIdUnique 508-mkTrFunKey = mkPreludeMiscIdUnique 509+mkTrTypeKey = mkPreludeMiscIdUnique 504+mkTrConKey = mkPreludeMiscIdUnique 505+mkTrAppKey = mkPreludeMiscIdUnique 506+typeNatTypeRepKey = mkPreludeMiscIdUnique 507+typeSymbolTypeRepKey = mkPreludeMiscIdUnique 508+typeRepIdKey = mkPreludeMiscIdUnique 509+mkTrFunKey = mkPreludeMiscIdUnique 510 -- Representations for primitive types trTYPEKey@@ -2332,10 +2355,10 @@ , trRuntimeRepKey , tr'PtrRepLiftedKey :: Unique-trTYPEKey = mkPreludeMiscIdUnique 510-trTYPE'PtrRepLiftedKey = mkPreludeMiscIdUnique 511-trRuntimeRepKey = mkPreludeMiscIdUnique 512-tr'PtrRepLiftedKey = mkPreludeMiscIdUnique 513+trTYPEKey = mkPreludeMiscIdUnique 511+trTYPE'PtrRepLiftedKey = mkPreludeMiscIdUnique 512+trRuntimeRepKey = mkPreludeMiscIdUnique 513+tr'PtrRepLiftedKey = mkPreludeMiscIdUnique 514 -- KindReps for common cases starKindRepKey, starArrStarKindRepKey, starArrStarArrStarKindRepKey :: Unique
prelude/PrelRules.hs view
@@ -25,6 +25,8 @@ #include "HsVersions.h" #include "MachDeps.h" +import GhcPrelude+ import {-# SOURCE #-} MkId ( mkPrimOpId, magicDictId ) import CoreSyn@@ -35,8 +37,9 @@ import PrimOp ( PrimOp(..), tagToEnumKey ) import TysWiredIn import TysPrim-import TyCon ( tyConDataCons_maybe, isEnumerationTyCon, isNewTyCon, unwrapNewTyCon_maybe )-import DataCon ( dataConTag, dataConTyCon, dataConWorkId )+import TyCon ( tyConDataCons_maybe, isAlgTyCon, isEnumerationTyCon+ , isNewTyCon, unwrapNewTyCon_maybe, tyConDataCons )+import DataCon ( DataCon, dataConTagZ, dataConTyCon, dataConWorkId ) import CoreUtils ( cheapEqExpr, exprIsHNF ) import CoreUnfold ( exprIsConApp_maybe ) import Type@@ -55,9 +58,7 @@ import Control.Applicative ( Alternative(..) ) import Control.Monad-#if __GLASGOW_HASKELL__ > 710 import qualified Control.Monad.Fail as MonadFail-#endif import Data.Bits as Bits import qualified Data.ByteString as BS import Data.Int@@ -121,11 +122,11 @@ , inversePrimOp NotIOp ] primOpRules nm IntNegOp = mkPrimOpRule nm 1 [ unaryLit negOp , inversePrimOp IntNegOp ]-primOpRules nm ISllOp = mkPrimOpRule nm 2 [ binaryLit (intOp2 Bits.shiftL)+primOpRules nm ISllOp = mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftL) , rightIdentityDynFlags zeroi ]-primOpRules nm ISraOp = mkPrimOpRule nm 2 [ binaryLit (intOp2 Bits.shiftR)+primOpRules nm ISraOp = mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftR) , rightIdentityDynFlags zeroi ]-primOpRules nm ISrlOp = mkPrimOpRule nm 2 [ binaryLit (intOp2' shiftRightLogical)+primOpRules nm ISrlOp = mkPrimOpRule nm 2 [ shiftRule shiftRightLogical , rightIdentityDynFlags zeroi ] -- Word operations@@ -156,8 +157,8 @@ , equalArgs >> retLit zerow ] primOpRules nm NotOp = mkPrimOpRule nm 1 [ unaryLit complementOp , inversePrimOp NotOp ]-primOpRules nm SllOp = mkPrimOpRule nm 2 [ wordShiftRule (const Bits.shiftL) ]-primOpRules nm SrlOp = mkPrimOpRule nm 2 [ wordShiftRule shiftRightLogical ]+primOpRules nm SllOp = mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftL) ]+primOpRules nm SrlOp = mkPrimOpRule nm 2 [ shiftRule shiftRightLogical ] -- coercions primOpRules nm Word2IntOp = mkPrimOpRule nm 1 [ liftLitDynFlags word2IntLit@@ -418,10 +419,10 @@ = wordResult dflags (fromInteger w1 `op` fromInteger w2) wordOp2 _ _ _ _ = Nothing -- Could find LitLit -wordShiftRule :: (DynFlags -> Integer -> Int -> Integer) -> RuleM CoreExpr+shiftRule :: (DynFlags -> Integer -> Int -> Integer) -> RuleM CoreExpr -- Shifts take an Int; hence third arg of op is Int -- See Note [Guarding against silly shifts]-wordShiftRule shift_op+shiftRule shift_op = do { dflags <- getDynFlags ; [e1, Lit (MachInt shift_len)] <- getArgs ; case e1 of@@ -430,10 +431,16 @@ | shift_len < 0 || wordSizeInBits dflags < shift_len -> return (mkRuntimeErrorApp rUNTIME_ERROR_ID wordPrimTy ("Bad shift length" ++ show shift_len))++ -- Do the shift at type Integer, but shift length is Int+ Lit (MachInt x)+ -> let op = shift_op dflags+ in liftMaybe $ intResult dflags (x `op` fromInteger shift_len)+ Lit (MachWord x) -> let op = shift_op dflags in liftMaybe $ wordResult dflags (x `op` fromInteger shift_len)- -- Do the shift at type Integer, but shift length is Int+ _ -> mzero } wordSizeInBits :: DynFlags -> Integer@@ -538,51 +545,15 @@ isMaxBound _ (MachWord64 i) = i == toInteger (maxBound :: Word64) isMaxBound _ _ = False ---- Note [Word/Int underflow/overflow]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ According to the Haskell Report 2010 (Sections 18.1 and 23.1 about signed and--- unsigned integral types): "All arithmetic is performed modulo 2^n, where n is--- the number of bits in the type."------ GHC stores Word# and Int# constant values as Integer. Core optimizations such--- as constant folding must ensure that the Integer value remains in the valid--- target Word/Int range (see #13172). The following functions are used to--- ensure this.------ Note that we *don't* warn the user about overflow. It's not done at runtime--- either, and compilation of completely harmless things like--- ((124076834 :: Word32) + (2147483647 :: Word32))--- doesn't yield a warning. Instead we simply squash the value into the *target*--- Int/Word range.---- | Ensure the given Integer is in the target Int range-intResult' :: DynFlags -> Integer -> Integer-intResult' dflags result = case platformWordSize (targetPlatform dflags) of- 4 -> toInteger (fromInteger result :: Int32)- 8 -> toInteger (fromInteger result :: Int64)- w -> panic ("intResult: Unknown platformWordSize: " ++ show w)---- | Ensure the given Integer is in the target Word range-wordResult' :: DynFlags -> Integer -> Integer-wordResult' dflags result = case platformWordSize (targetPlatform dflags) of- 4 -> toInteger (fromInteger result :: Word32)- 8 -> toInteger (fromInteger result :: Word64)- w -> panic ("wordResult: Unknown platformWordSize: " ++ show w)- -- | Create an Int literal expression while ensuring the given Integer is in the -- target Int range intResult :: DynFlags -> Integer -> Maybe CoreExpr-intResult dflags result = Just (mkIntVal dflags (intResult' dflags result))+intResult dflags result = Just (Lit (mkMachIntWrap dflags result)) -- | Create a Word literal expression while ensuring the given Integer is in the -- target Word range wordResult :: DynFlags -> Integer -> Maybe CoreExpr-wordResult dflags result = Just (mkWordVal dflags (wordResult' dflags result))---+wordResult dflags result = Just (Lit (mkMachWordWrap dflags result)) inversePrimOp :: PrimOp -> RuleM CoreExpr inversePrimOp primop = do@@ -684,12 +655,10 @@ RuleM f >>= g = RuleM $ \dflags iu e -> case f dflags iu e of Nothing -> Nothing Just r -> runRuleM (g r) dflags iu e- fail _ = mzero+ fail = MonadFail.fail -#if __GLASGOW_HASKELL__ > 710 instance MonadFail.MonadFail RuleM where fail _ = mzero-#endif instance Alternative RuleM where empty = RuleM $ \_ _ _ -> Nothing@@ -872,8 +841,6 @@ mkIntVal :: DynFlags -> Integer -> Expr CoreBndr mkIntVal dflags i = Lit (mkMachInt dflags i)-mkWordVal :: DynFlags -> Integer -> Expr CoreBndr-mkWordVal dflags w = Lit (mkMachWord dflags w) mkFloatVal :: DynFlags -> Rational -> Expr CoreBndr mkFloatVal dflags f = Lit (convFloating dflags (MachFloat f)) mkDoubleVal :: DynFlags -> Rational -> Expr CoreBndr@@ -921,7 +888,7 @@ case splitTyConApp_maybe ty of Just (tycon, tc_args) | isEnumerationTyCon tycon -> do let tag = fromInteger i- correct_tag dc = (dataConTag dc - fIRST_TAG) == tag+ correct_tag dc = (dataConTagZ dc) == tag (dc:rest) <- return $ filter correct_tag (tyConDataCons_maybe tycon `orElse` []) ASSERT(null rest) return () return $ mkTyApps (Var (dataConWorkId dc)) tc_args@@ -930,28 +897,29 @@ _ -> WARN( True, text "tagToEnum# on non-enumeration type" <+> ppr ty ) return $ mkRuntimeErrorApp rUNTIME_ERROR_ID ty "tagToEnum# on non-enumeration type" -{--For dataToTag#, we can reduce if either-- (a) the argument is a constructor- (b) the argument is a variable whose unfolding is a known constructor--}-+------------------------------ dataToTagRule :: RuleM CoreExpr+-- Rules for dataToTag# dataToTagRule = a `mplus` b where+ -- dataToTag (tagToEnum x) ==> x a = do [Type ty1, Var tag_to_enum `App` Type ty2 `App` tag] <- getArgs guard $ tag_to_enum `hasKey` tagToEnumKey guard $ ty1 `eqType` ty2- return tag -- dataToTag (tagToEnum x) ==> x+ return tag++ -- dataToTag (K e1 e2) ==> tag-of K+ -- This also works (via exprIsConApp_maybe) for+ -- dataToTag x+ -- where x's unfolding is a constructor application b = do dflags <- getDynFlags [_, val_arg] <- getArgs in_scope <- getInScopeEnv (dc,_,_) <- liftMaybe $ exprIsConApp_maybe in_scope val_arg ASSERT( not (isNewTyCon (dataConTyCon dc)) ) return ()- return $ mkIntVal dflags (toInteger (dataConTag dc - fIRST_TAG))+ return $ mkIntVal dflags (toInteger (dataConTagZ dc)) {- ************************************************************************@@ -1041,6 +1009,9 @@ ] ] ++ builtinIntegerRules+{-# NOINLINE builtinRules #-}+-- there is no benefit to inlining these yet, despite this, GHC produces+-- unfoldings for this regardless since the floated list entries look small. builtinIntegerRules :: [CoreRule] builtinIntegerRules =@@ -1183,7 +1154,7 @@ --------------------------------------------------- -- The rule is this:--- eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2) = s1==s2+-- eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2)) = s1==s2 match_eq_string :: RuleFun match_eq_string _ id_unf _@@ -1432,46 +1403,171 @@ -- | Match the scrutinee of a case and potentially return a new scrutinee and a -- function to apply to each literal alternative.-caseRules :: DynFlags -> CoreExpr -> Maybe (CoreExpr, Integer -> Integer)-caseRules dflags scrut = case scrut of+caseRules :: DynFlags+ -> CoreExpr -- Scrutinee+ -> Maybe ( CoreExpr -- New scrutinee+ , AltCon -> AltCon -- How to fix up the alt pattern+ , Id -> CoreExpr) -- How to reconstruct the original scrutinee+ -- from the new case-binder+-- e.g case e of b {+-- ...;+-- con bs -> rhs;+-- ... }+-- ==>+-- case e' of b' {+-- ...;+-- fixup_altcon[con] bs -> let b = mk_orig[b] in rhs;+-- ... } - -- We need to call wordResult' and intResult' to ensure that the literal- -- alternatives remain in Word/Int target ranges (cf Note [Word/Int- -- underflow/overflow] and #13172).+caseRules dflags (App (App (Var f) v) (Lit l)) -- v `op` x#+ | Just op <- isPrimOpId_maybe f+ , Just x <- isLitValue_maybe l+ , Just adjust_lit <- adjustDyadicRight op x+ = Just (v, tx_lit_con dflags adjust_lit+ , \v -> (App (App (Var f) (Var v)) (Lit l))) - -- v `op` x#- App (App (Var f) v) (Lit l)- | Just op <- isPrimOpId_maybe f- , Just x <- isLitValue_maybe l ->- case op of- WordAddOp -> Just (v, \y -> wordResult' dflags $ y-x )- IntAddOp -> Just (v, \y -> intResult' dflags $ y-x )- WordSubOp -> Just (v, \y -> wordResult' dflags $ y+x )- IntSubOp -> Just (v, \y -> intResult' dflags $ y+x )- XorOp -> Just (v, \y -> wordResult' dflags $ y `xor` x)- XorIOp -> Just (v, \y -> intResult' dflags $ y `xor` x)+caseRules dflags (App (App (Var f) (Lit l)) v) -- x# `op` v+ | Just op <- isPrimOpId_maybe f+ , Just x <- isLitValue_maybe l+ , Just adjust_lit <- adjustDyadicLeft x op+ = Just (v, tx_lit_con dflags adjust_lit+ , \v -> (App (App (Var f) (Lit l)) (Var v)))+++caseRules dflags (App (Var f) v ) -- op v+ | Just op <- isPrimOpId_maybe f+ , Just adjust_lit <- adjustUnary op+ = Just (v, tx_lit_con dflags adjust_lit+ , \v -> App (Var f) (Var v))++-- See Note [caseRules for tagToEnum]+caseRules dflags (App (App (Var f) type_arg) v)+ | Just TagToEnumOp <- isPrimOpId_maybe f+ = Just (v, tx_con_tte dflags+ , \v -> (App (App (Var f) type_arg) (Var v)))++-- See Note [caseRules for dataToTag]+caseRules _ (App (App (Var f) (Type ty)) v) -- dataToTag x+ | Just DataToTagOp <- isPrimOpId_maybe f+ , Just (tc, _) <- tcSplitTyConApp_maybe ty+ , isAlgTyCon tc+ = Just (v, tx_con_dtt ty+ , \v -> App (App (Var f) (Type ty)) (Var v))++caseRules _ _ = Nothing+++tx_lit_con :: DynFlags -> (Integer -> Integer) -> AltCon -> AltCon+tx_lit_con _ _ DEFAULT = DEFAULT+tx_lit_con dflags adjust (LitAlt l) = LitAlt (mapLitValue dflags adjust l)+tx_lit_con _ _ alt = pprPanic "caseRules" (ppr alt)+ -- NB: mapLitValue uses mkMachIntWrap etc, to ensure that the+ -- literal alternatives remain in Word/Int target ranges+ -- (See Note [Word/Int underflow/overflow] in Literal and #13172).++adjustDyadicRight :: PrimOp -> Integer -> Maybe (Integer -> Integer)+-- Given (x `op` lit) return a function 'f' s.t. f (x `op` lit) = x+adjustDyadicRight op lit+ = case op of+ WordAddOp -> Just (\y -> y-lit )+ IntAddOp -> Just (\y -> y-lit )+ WordSubOp -> Just (\y -> y+lit )+ IntSubOp -> Just (\y -> y+lit )+ XorOp -> Just (\y -> y `xor` lit)+ XorIOp -> Just (\y -> y `xor` lit) _ -> Nothing - -- x# `op` v- App (App (Var f) (Lit l)) v- | Just op <- isPrimOpId_maybe f- , Just x <- isLitValue_maybe l ->- case op of- WordAddOp -> Just (v, \y -> wordResult' dflags $ y-x )- IntAddOp -> Just (v, \y -> intResult' dflags $ y-x )- WordSubOp -> Just (v, \y -> wordResult' dflags $ x-y )- IntSubOp -> Just (v, \y -> intResult' dflags $ x-y )- XorOp -> Just (v, \y -> wordResult' dflags $ y `xor` x)- XorIOp -> Just (v, \y -> intResult' dflags $ y `xor` x)+adjustDyadicLeft :: Integer -> PrimOp -> Maybe (Integer -> Integer)+-- Given (lit `op` x) return a function 'f' s.t. f (lit `op` x) = x+adjustDyadicLeft lit op+ = case op of+ WordAddOp -> Just (\y -> y-lit )+ IntAddOp -> Just (\y -> y-lit )+ WordSubOp -> Just (\y -> lit-y )+ IntSubOp -> Just (\y -> lit-y )+ XorOp -> Just (\y -> y `xor` lit)+ XorIOp -> Just (\y -> y `xor` lit) _ -> Nothing - -- op v- App (Var f) v- | Just op <- isPrimOpId_maybe f ->- case op of- NotOp -> Just (v, \y -> wordResult' dflags $ complement y)- NotIOp -> Just (v, \y -> intResult' dflags $ complement y)- IntNegOp -> Just (v, \y -> intResult' dflags $ negate y )++adjustUnary :: PrimOp -> Maybe (Integer -> Integer)+-- Given (op x) return a function 'f' s.t. f (op x) = x+adjustUnary op+ = case op of+ NotOp -> Just (\y -> complement y)+ NotIOp -> Just (\y -> complement y)+ IntNegOp -> Just (\y -> negate y ) _ -> Nothing - _ -> Nothing+tx_con_tte :: DynFlags -> AltCon -> AltCon+tx_con_tte _ DEFAULT = DEFAULT+tx_con_tte _ alt@(LitAlt {}) = pprPanic "caseRules" (ppr alt)+tx_con_tte dflags (DataAlt dc) -- See Note [caseRules for tagToEnum]+ = LitAlt $ mkMachInt dflags $ toInteger $ dataConTagZ dc++tx_con_dtt :: Type -> AltCon -> AltCon+tx_con_dtt _ DEFAULT = DEFAULT+tx_con_dtt ty (LitAlt (MachInt i)) = DataAlt (get_con ty (fromInteger i))+tx_con_dtt _ alt = pprPanic "caseRules" (ppr alt)++get_con :: Type -> ConTagZ -> DataCon+get_con ty tag = tyConDataCons (tyConAppTyCon ty) !! tag++{- Note [caseRules for tagToEnum]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We want to transform+ case tagToEnum x of+ False -> e1+ True -> e2+into+ case x of+ 0# -> e1+ 1# -> e2++This rule eliminates a lot of boilerplate. For+ if (x>y) then e2 else e1+we generate+ case tagToEnum (x ># y) of+ False -> e1+ True -> e2+and it is nice to then get rid of the tagToEnum.++Beware (Trac #14768): avoid the temptation to map constructor 0 to+DEFAULT, in the hope of getting this+ case (x ># y) of+ DEFAULT -> e1+ 1# -> e2+That fails utterly in the case of+ data Colour = Red | Green | Blue+ case tagToEnum x of+ DEFAULT -> e1+ Red -> e2++We don't want to get this!+ case x of+ DEFAULT -> e1+ DEFAULT -> e2++Instead, we deal with turning one branch into DEAFULT in SimplUtils+(add_default in mkCase3).++Note [caseRules for dataToTag]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We want to transform+ case dataToTag x of+ DEFAULT -> e1+ 1# -> e2+into+ case x of+ DEFAULT -> e1+ (:) _ _ -> e2++Note the need for some wildcard binders in+the 'cons' case.++For the time, we only apply this transformation when the type of `x` is a type+headed by a normal tycon. In particular, we do not apply this in the case of a+data family tycon, since that would require carefully applying coercion(s)+between the data family and the data family instance's representation type,+which caseRules isn't currently engineered to handle (#14680).+-}
prelude/PrimOp.hs view
@@ -7,9 +7,7 @@ {-# LANGUAGE CPP #-} -- The default is a bit too low for the quite large primOpInfo definition-#if __GLASGOW_HASKELL__ >= 801 {-# OPTIONS_GHC -fmax-pmcheck-iterations=10000000 #-}-#endif module PrimOp ( PrimOp(..), PrimOpVecCat(..), allThePrimOps,@@ -22,13 +20,15 @@ primOpOkForSpeculation, primOpOkForSideEffects, primOpIsCheap, primOpFixity, - getPrimOpResultInfo, PrimOpResultInfo(..),+ getPrimOpResultInfo, isComparisonPrimOp, PrimOpResultInfo(..), PrimCall(..) ) where #include "HsVersions.h" +import GhcPrelude+ import TysPrim import TysWiredIn @@ -551,6 +551,11 @@ Monadic occ _ -> occ Compare occ _ -> occ GenPrimOp occ _ _ _ -> occ++isComparisonPrimOp :: PrimOp -> Bool+isComparisonPrimOp op = case primOpInfo op of+ Compare {} -> True+ _ -> False -- primOpSig is like primOpType but gives the result split apart: -- (type variables, argument types, result type)
prelude/PrimOp.hs-boot view
@@ -1,3 +1,5 @@ module PrimOp where +import GhcPrelude ()+ data PrimOp
prelude/THNames.hs view
@@ -6,6 +6,8 @@ module THNames where +import GhcPrelude ()+ import PrelNames( mk_known_key_name ) import Module( Module, mkModuleNameFS, mkModule, thUnitId ) import Name( Name )@@ -54,6 +56,7 @@ condEName, multiIfEName, letEName, caseEName, doEName, compEName, fromEName, fromThenEName, fromToEName, fromThenToEName, listEName, sigEName, recConEName, recUpdEName, staticEName, unboundVarEName,+ labelEName, -- FieldExp fieldExpName, -- Body@@ -134,8 +137,6 @@ ruleVarName, typedRuleVarName, -- FunDep funDepName,- -- FamFlavour- typeFamName, dataFamName, -- TySynEqn tySynEqnName, -- AnnTarget@@ -151,10 +152,10 @@ clauseQTyConName, expQTyConName, fieldExpTyConName, predTyConName, stmtQTyConName, decQTyConName, conQTyConName, bangTypeQTyConName, varBangTypeQTyConName, typeQTyConName, expTyConName, decTyConName,- typeTyConName, tyVarBndrTyConName, matchTyConName, clauseTyConName,+ typeTyConName, tyVarBndrQTyConName, matchTyConName, clauseTyConName, patQTyConName, fieldPatQTyConName, fieldExpQTyConName, funDepTyConName, predQTyConName, decsQTyConName, ruleBndrQTyConName, tySynEqnQTyConName,- roleTyConName, tExpTyConName, injAnnTyConName, kindTyConName,+ roleTyConName, tExpTyConName, injAnnTyConName, kindQTyConName, overlapTyConName, derivClauseQTyConName, derivStrategyTyConName, -- Quasiquoting@@ -162,7 +163,7 @@ thSyn, thLib, qqLib :: Module thSyn = mkTHModule (fsLit "Language.Haskell.TH.Syntax")-thLib = mkTHModule (fsLit "Language.Haskell.TH.Lib")+thLib = mkTHModule (fsLit "Language.Haskell.TH.Lib.Internal") qqLib = mkTHModule (fsLit "Language.Haskell.TH.Quote") mkTHModule :: FastString -> Module@@ -183,9 +184,9 @@ qTyConName, nameTyConName, fieldExpTyConName, patTyConName, fieldPatTyConName, expTyConName, decTyConName, typeTyConName,- tyVarBndrTyConName, matchTyConName, clauseTyConName, funDepTyConName,- predTyConName, tExpTyConName, injAnnTyConName, kindTyConName,- overlapTyConName, derivStrategyTyConName :: Name+ matchTyConName, clauseTyConName, funDepTyConName, predTyConName,+ tExpTyConName, injAnnTyConName, overlapTyConName,+ derivStrategyTyConName :: Name qTyConName = thTc (fsLit "Q") qTyConKey nameTyConName = thTc (fsLit "Name") nameTyConKey fieldExpTyConName = thTc (fsLit "FieldExp") fieldExpTyConKey@@ -194,14 +195,12 @@ expTyConName = thTc (fsLit "Exp") expTyConKey decTyConName = thTc (fsLit "Dec") decTyConKey typeTyConName = thTc (fsLit "Type") typeTyConKey-tyVarBndrTyConName = thTc (fsLit "TyVarBndr") tyVarBndrTyConKey matchTyConName = thTc (fsLit "Match") matchTyConKey clauseTyConName = thTc (fsLit "Clause") clauseTyConKey funDepTyConName = thTc (fsLit "FunDep") funDepTyConKey predTyConName = thTc (fsLit "Pred") predTyConKey tExpTyConName = thTc (fsLit "TExp") tExpTyConKey injAnnTyConName = thTc (fsLit "InjectivityAnn") injAnnTyConKey-kindTyConName = thTc (fsLit "Kind") kindTyConKey overlapTyConName = thTc (fsLit "Overlap") overlapTyConKey derivStrategyTyConName = thTc (fsLit "DerivStrategy") derivStrategyTyConKey @@ -278,7 +277,8 @@ varEName, conEName, litEName, appEName, appTypeEName, infixEName, infixAppName, sectionLName, sectionRName, lamEName, lamCaseEName, tupEName, unboxedTupEName, unboxedSumEName, condEName, multiIfEName, letEName,- caseEName, doEName, compEName, staticEName, unboundVarEName :: Name+ caseEName, doEName, compEName, staticEName, unboundVarEName,+ labelEName :: Name varEName = libFun (fsLit "varE") varEIdKey conEName = libFun (fsLit "conE") conEIdKey litEName = libFun (fsLit "litE") litEIdKey@@ -313,6 +313,7 @@ recUpdEName = libFun (fsLit "recUpdE") recUpdEIdKey staticEName = libFun (fsLit "staticE") staticEIdKey unboundVarEName = libFun (fsLit "unboundVarE") unboundVarEIdKey+labelEName = libFun (fsLit "labelE") labelEIdKey -- type FieldExp = ... fieldExpName :: Name@@ -344,38 +345,36 @@ openTypeFamilyDName, closedTypeFamilyDName, infixLDName, infixRDName, infixNDName, roleAnnotDName, patSynDName, patSynSigDName, pragCompleteDName :: Name-funDName = libFun (fsLit "funD") funDIdKey-valDName = libFun (fsLit "valD") valDIdKey-dataDName = libFun (fsLit "dataD") dataDIdKey-newtypeDName = libFun (fsLit "newtypeD") newtypeDIdKey-tySynDName = libFun (fsLit "tySynD") tySynDIdKey-classDName = libFun (fsLit "classD") classDIdKey-instanceWithOverlapDName- = libFun (fsLit "instanceWithOverlapD") instanceWithOverlapDIdKey-standaloneDerivWithStrategyDName = libFun- (fsLit "standaloneDerivWithStrategyD") standaloneDerivWithStrategyDIdKey-sigDName = libFun (fsLit "sigD") sigDIdKey-defaultSigDName = libFun (fsLit "defaultSigD") defaultSigDIdKey-forImpDName = libFun (fsLit "forImpD") forImpDIdKey-pragInlDName = libFun (fsLit "pragInlD") pragInlDIdKey-pragSpecDName = libFun (fsLit "pragSpecD") pragSpecDIdKey-pragSpecInlDName = libFun (fsLit "pragSpecInlD") pragSpecInlDIdKey-pragSpecInstDName = libFun (fsLit "pragSpecInstD") pragSpecInstDIdKey-pragRuleDName = libFun (fsLit "pragRuleD") pragRuleDIdKey-pragCompleteDName = libFun (fsLit "pragCompleteD") pragCompleteDIdKey-pragAnnDName = libFun (fsLit "pragAnnD") pragAnnDIdKey-dataInstDName = libFun (fsLit "dataInstD") dataInstDIdKey-newtypeInstDName = libFun (fsLit "newtypeInstD") newtypeInstDIdKey-tySynInstDName = libFun (fsLit "tySynInstD") tySynInstDIdKey-openTypeFamilyDName = libFun (fsLit "openTypeFamilyD") openTypeFamilyDIdKey-closedTypeFamilyDName= libFun (fsLit "closedTypeFamilyD") closedTypeFamilyDIdKey-dataFamilyDName = libFun (fsLit "dataFamilyD") dataFamilyDIdKey-infixLDName = libFun (fsLit "infixLD") infixLDIdKey-infixRDName = libFun (fsLit "infixRD") infixRDIdKey-infixNDName = libFun (fsLit "infixND") infixNDIdKey-roleAnnotDName = libFun (fsLit "roleAnnotD") roleAnnotDIdKey-patSynDName = libFun (fsLit "patSynD") patSynDIdKey-patSynSigDName = libFun (fsLit "patSynSigD") patSynSigDIdKey+funDName = libFun (fsLit "funD") funDIdKey+valDName = libFun (fsLit "valD") valDIdKey+dataDName = libFun (fsLit "dataD") dataDIdKey+newtypeDName = libFun (fsLit "newtypeD") newtypeDIdKey+tySynDName = libFun (fsLit "tySynD") tySynDIdKey+classDName = libFun (fsLit "classD") classDIdKey+instanceWithOverlapDName = libFun (fsLit "instanceWithOverlapD") instanceWithOverlapDIdKey+standaloneDerivWithStrategyDName = libFun (fsLit "standaloneDerivWithStrategyD") standaloneDerivWithStrategyDIdKey+sigDName = libFun (fsLit "sigD") sigDIdKey+defaultSigDName = libFun (fsLit "defaultSigD") defaultSigDIdKey+forImpDName = libFun (fsLit "forImpD") forImpDIdKey+pragInlDName = libFun (fsLit "pragInlD") pragInlDIdKey+pragSpecDName = libFun (fsLit "pragSpecD") pragSpecDIdKey+pragSpecInlDName = libFun (fsLit "pragSpecInlD") pragSpecInlDIdKey+pragSpecInstDName = libFun (fsLit "pragSpecInstD") pragSpecInstDIdKey+pragRuleDName = libFun (fsLit "pragRuleD") pragRuleDIdKey+pragCompleteDName = libFun (fsLit "pragCompleteD") pragCompleteDIdKey+pragAnnDName = libFun (fsLit "pragAnnD") pragAnnDIdKey+dataInstDName = libFun (fsLit "dataInstD") dataInstDIdKey+newtypeInstDName = libFun (fsLit "newtypeInstD") newtypeInstDIdKey+tySynInstDName = libFun (fsLit "tySynInstD") tySynInstDIdKey+openTypeFamilyDName = libFun (fsLit "openTypeFamilyD") openTypeFamilyDIdKey+closedTypeFamilyDName = libFun (fsLit "closedTypeFamilyD") closedTypeFamilyDIdKey+dataFamilyDName = libFun (fsLit "dataFamilyD") dataFamilyDIdKey+infixLDName = libFun (fsLit "infixLD") infixLDIdKey+infixRDName = libFun (fsLit "infixRD") infixRDIdKey+infixNDName = libFun (fsLit "infixND") infixNDIdKey+roleAnnotDName = libFun (fsLit "roleAnnotD") roleAnnotDIdKey+patSynDName = libFun (fsLit "patSynD") patSynDIdKey+patSynSigDName = libFun (fsLit "patSynSigD") patSynSigDIdKey -- type Ctxt = ... cxtName :: Name@@ -428,9 +427,10 @@ -- data Type = ... forallTName, varTName, conTName, tupleTName, unboxedTupleTName,- unboxedSumTName, arrowTName, listTName, appTName, sigTName, equalityTName,- litTName, promotedTName, promotedTupleTName, promotedNilTName,- promotedConsTName, wildCardTName :: Name+ unboxedSumTName, arrowTName, listTName, appTName, sigTName,+ equalityTName, litTName, promotedTName,+ promotedTupleTName, promotedNilTName, promotedConsTName,+ wildCardTName :: Name forallTName = libFun (fsLit "forallT") forallTIdKey varTName = libFun (fsLit "varT") varTIdKey conTName = libFun (fsLit "conT") conTIdKey@@ -456,8 +456,8 @@ -- data TyVarBndr = ... plainTVName, kindedTVName :: Name-plainTVName = libFun (fsLit "plainTV") plainTVIdKey-kindedTVName = libFun (fsLit "kindedTV") kindedTVIdKey+plainTVName = libFun (fsLit "plainTV") plainTVIdKey+kindedTVName = libFun (fsLit "kindedTV") kindedTVIdKey -- data Role = ... nominalRName, representationalRName, phantomRName, inferRName :: Name@@ -480,9 +480,9 @@ -- data FamilyResultSig = ... noSigName, kindSigName, tyVarSigName :: Name-noSigName = libFun (fsLit "noSig") noSigIdKey-kindSigName = libFun (fsLit "kindSig") kindSigIdKey-tyVarSigName = libFun (fsLit "tyVarSig") tyVarSigIdKey+noSigName = libFun (fsLit "noSig") noSigIdKey+kindSigName = libFun (fsLit "kindSig") kindSigIdKey+tyVarSigName = libFun (fsLit "tyVarSig") tyVarSigIdKey -- data InjectivityAnn = ... injectivityAnnName :: Name@@ -515,11 +515,6 @@ funDepName :: Name funDepName = libFun (fsLit "funDep") funDepIdKey --- data FamFlavour = ...-typeFamName, dataFamName :: Name-typeFamName = libFun (fsLit "typeFam") typeFamIdKey-dataFamName = libFun (fsLit "dataFam") dataFamIdKey- -- data TySynEqn = ... tySynEqnName :: Name tySynEqnName = libFun (fsLit "tySynEqn") tySynEqnIdKey@@ -539,7 +534,7 @@ varBangTypeQTyConName, typeQTyConName, fieldExpQTyConName, patQTyConName, fieldPatQTyConName, predQTyConName, decsQTyConName, ruleBndrQTyConName, tySynEqnQTyConName, roleTyConName,- derivClauseQTyConName :: Name+ derivClauseQTyConName, kindQTyConName, tyVarBndrQTyConName :: Name matchQTyConName = libTc (fsLit "MatchQ") matchQTyConKey clauseQTyConName = libTc (fsLit "ClauseQ") clauseQTyConKey expQTyConName = libTc (fsLit "ExpQ") expQTyConKey@@ -558,6 +553,8 @@ tySynEqnQTyConName = libTc (fsLit "TySynEqnQ") tySynEqnQTyConKey roleTyConName = libTc (fsLit "Role") roleTyConKey derivClauseQTyConName = libTc (fsLit "DerivClauseQ") derivClauseQTyConKey+kindQTyConName = libTc (fsLit "KindQ") kindQTyConKey+tyVarBndrQTyConName = libTc (fsLit "TyVarBndrQ") tyVarBndrQTyConKey -- quasiquoting quoteExpName, quotePatName, quoteDecName, quoteTypeName :: Name@@ -623,12 +620,12 @@ expTyConKey, matchTyConKey, clauseTyConKey, qTyConKey, expQTyConKey, decQTyConKey, patTyConKey, matchQTyConKey, clauseQTyConKey,- stmtQTyConKey, conQTyConKey, typeQTyConKey, typeTyConKey, tyVarBndrTyConKey,- decTyConKey, bangTypeQTyConKey, varBangTypeQTyConKey,+ stmtQTyConKey, conQTyConKey, typeQTyConKey, typeTyConKey,+ tyVarBndrQTyConKey, decTyConKey, bangTypeQTyConKey, varBangTypeQTyConKey, fieldExpTyConKey, fieldPatTyConKey, nameTyConKey, patQTyConKey, fieldPatQTyConKey, fieldExpQTyConKey, funDepTyConKey, predTyConKey, predQTyConKey, decsQTyConKey, ruleBndrQTyConKey, tySynEqnQTyConKey,- roleTyConKey, tExpTyConKey, injAnnTyConKey, kindTyConKey,+ roleTyConKey, tExpTyConKey, injAnnTyConKey, kindQTyConKey, overlapTyConKey, derivClauseQTyConKey, derivStrategyTyConKey :: Unique expTyConKey = mkPreludeTyConUnique 200 matchTyConKey = mkPreludeTyConUnique 201@@ -655,14 +652,14 @@ funDepTyConKey = mkPreludeTyConUnique 222 predTyConKey = mkPreludeTyConUnique 223 predQTyConKey = mkPreludeTyConUnique 224-tyVarBndrTyConKey = mkPreludeTyConUnique 225+tyVarBndrQTyConKey = mkPreludeTyConUnique 225 decsQTyConKey = mkPreludeTyConUnique 226 ruleBndrQTyConKey = mkPreludeTyConUnique 227 tySynEqnQTyConKey = mkPreludeTyConUnique 228 roleTyConKey = mkPreludeTyConUnique 229 tExpTyConKey = mkPreludeTyConUnique 230 injAnnTyConKey = mkPreludeTyConUnique 231-kindTyConKey = mkPreludeTyConUnique 232+kindQTyConKey = mkPreludeTyConUnique 232 overlapTyConKey = mkPreludeTyConUnique 233 derivClauseQTyConKey = mkPreludeTyConUnique 234 derivStrategyTyConKey = mkPreludeTyConUnique 235@@ -800,7 +797,7 @@ letEIdKey, caseEIdKey, doEIdKey, compEIdKey, fromEIdKey, fromThenEIdKey, fromToEIdKey, fromThenToEIdKey, listEIdKey, sigEIdKey, recConEIdKey, recUpdEIdKey, staticEIdKey,- unboundVarEIdKey :: Unique+ unboundVarEIdKey, labelEIdKey :: Unique varEIdKey = mkPreludeMiscIdUnique 270 conEIdKey = mkPreludeMiscIdUnique 271 litEIdKey = mkPreludeMiscIdUnique 272@@ -831,6 +828,7 @@ recUpdEIdKey = mkPreludeMiscIdUnique 297 staticEIdKey = mkPreludeMiscIdUnique 298 unboundVarEIdKey = mkPreludeMiscIdUnique 299+labelEIdKey = mkPreludeMiscIdUnique 300 -- type FieldExp = ... fieldExpIdKey :: Unique@@ -947,8 +945,9 @@ -- data Type = ... forallTIdKey, varTIdKey, conTIdKey, tupleTIdKey, unboxedTupleTIdKey, unboxedSumTIdKey, arrowTIdKey, listTIdKey, appTIdKey, sigTIdKey,- equalityTIdKey, litTIdKey, promotedTIdKey, promotedTupleTIdKey,- promotedNilTIdKey, promotedConsTIdKey, wildCardTIdKey :: Unique+ equalityTIdKey, litTIdKey, promotedTIdKey,+ promotedTupleTIdKey, promotedNilTIdKey, promotedConsTIdKey,+ wildCardTIdKey :: Unique forallTIdKey = mkPreludeMiscIdUnique 381 varTIdKey = mkPreludeMiscIdUnique 382 conTIdKey = mkPreludeMiscIdUnique 383@@ -1024,11 +1023,6 @@ -- data FunDep = ... funDepIdKey :: Unique funDepIdKey = mkPreludeMiscIdUnique 440---- data FamFlavour = ...-typeFamIdKey, dataFamIdKey :: Unique-typeFamIdKey = mkPreludeMiscIdUnique 450-dataFamIdKey = mkPreludeMiscIdUnique 451 -- data TySynEqn = ... tySynEqnIdKey :: Unique
prelude/TysPrim.hs view
@@ -80,6 +80,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} TysWiredIn ( runtimeRepTy, unboxedTupleKind, liftedTypeKind , vecRepDataConTyCon, tupleRepDataConTyCon@@ -235,7 +237,7 @@ -- b with unique (mkAlphaTyVarUnique n+1) -- ... etc -- Typically called as--- mkTemplateTyVarsFrom (legth kv_bndrs) kinds+-- mkTemplateTyVarsFrom (length kv_bndrs) kinds -- where kv_bndrs are the kind-level binders of a TyCon mkTemplateTyVarsFrom n kinds = [ mkTyVar name kind@@ -580,18 +582,19 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GHC sports a veritable menagerie of equality types: - Hetero? Levity Result Role Defining module- ------------------------------------------------------------- ~# hetero unlifted # nominal GHC.Prim- ~~ hetero lifted Constraint nominal GHC.Types- ~ homo lifted Constraint nominal Data.Type.Equality- :~: homo lifted * nominal Data.Type.Equality-- ~R# hetero unlifted # repr GHC.Prim- Coercible homo lifted Constraint repr GHC.Types- Coercion homo lifted * repr Data.Type.Coercion+ Type or Lifted? Hetero? Role Built in Defining module+ class? L/U TyCon+-----------------------------------------------------------------------------------------+~# T U hetero nominal eqPrimTyCon GHC.Prim+~~ C L hetero nominal hEqTyCon GHC.Types+~ C L homo nominal eqTyCon Data.Type.Equality+:~: T L homo nominal (not built-in) Data.Type.Equality+:~~: T L hetero nominal (not built-in) Data.Type.Equality - ~P# hetero unlifted phantom GHC.Prim+~R# T U hetero repr eqReprPrimTy GHC.Prim+Coercible C L homo repr coercibleTyCon GHC.Types+Coercion T L homo repr (not built-in) Data.Type.Coercion+~P# T U hetero phantom eqPhantPrimTyCon GHC.Prim Recall that "hetero" means the equality can related types of different kinds. Knowing that (t1 ~# t2) or (t1 ~R# t2) or even that (t1 ~P# t2)@@ -636,8 +639,8 @@ * It is "naturally coherent". This means that the solver won't hesitate to solve a goal of type (a ~~ b) even if there is, say (Int ~~ c) in the context. (Normally, it waits to learn more, just in case the given- influences what happens next.) This is quite like having- IncoherentInstances enabled.+ influences what happens next.) See Note [Naturally coherent classes]+ in TcInteract. * It always terminates. That is, in the UndecidableInstances checks, we don't worry if a (~~) constraint is too big, as we know that solving@@ -664,8 +667,8 @@ * It is "naturally coherent". (See (~~).) - * (~) is magical syntax, as ~ is a reserved symbol. It cannot be exported- or imported.+ * (~) is magical syntax, as ~ is a reserved symbol.+ It cannot be exported or imported. * It always terminates. @@ -675,9 +678,10 @@ -------------------------- (:~:) :: forall k. k -> k -> *+ (:~~:) :: forall k1 k2. k1 -> k2 -> * ---------------------------This is a perfectly ordinary GADT, wrapping (~). It is not defined within-GHC at all.+These are perfectly ordinary GADTs, wrapping (~) and (~~) resp.+They are not defined within GHC at all. --------------------------
prelude/TysWiredIn.hs view
@@ -102,7 +102,7 @@ -- * Equality predicates heqTyCon, heqClass, heqDataCon,- coercibleTyCon, coercibleDataCon, coercibleClass,+ coercibleTyCon, coercibleTyConName, coercibleDataCon, coercibleClass, -- * RuntimeRep and friends runtimeRepTyCon, vecCountTyCon, vecElemTyCon,@@ -128,6 +128,8 @@ #include "HsVersions.h" #include "MachDeps.h" +import GhcPrelude+ import {-# SOURCE #-} MkId( mkDataConWorkId, mkDictSelId ) -- friends:@@ -162,10 +164,6 @@ import BooleanFormula ( mkAnd ) import qualified Data.ByteString.Char8 as BS-#if !MIN_VERSION_bytestring(0,10,8)-import qualified Data.ByteString.Internal as BSI-import qualified Data.ByteString.Unsafe as BSU-#endif alpha_tyvar :: [TyVar] alpha_tyvar = [alphaTyVar]@@ -492,12 +490,15 @@ False -- Not in GADT syntax pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon-pcDataCon n univs = pcDataConWithFixity False n univs [] -- no ex_tvs+pcDataCon n univs = pcDataConWithFixity False n univs+ [] -- no ex_tvs+ univs -- the univs are precisely the user-written tyvars pcDataConWithFixity :: Bool -- ^ declared infix? -> Name -- ^ datacon name -> [TyVar] -- ^ univ tyvars -> [TyVar] -- ^ ex tyvars+ -> [TyVar] -- ^ user-written tyvars -> [Type] -- ^ args -> TyCon -> DataCon@@ -511,19 +512,20 @@ -- one DataCon unique per pair of Ints. pcDataConWithFixity' :: Bool -> Name -> Unique -> RuntimeRepInfo- -> [TyVar] -> [TyVar]+ -> [TyVar] -> [TyVar] -> [TyVar] -> [Type] -> TyCon -> DataCon -- The Name should be in the DataName name space; it's the name -- of the DataCon itself. -pcDataConWithFixity' declared_infix dc_name wrk_key rri tyvars ex_tyvars arg_tys tycon+pcDataConWithFixity' declared_infix dc_name wrk_key rri+ tyvars ex_tyvars user_tyvars arg_tys tycon = data_con where data_con = mkDataCon dc_name declared_infix prom_info (map (const no_bang) arg_tys) [] -- No labelled fields- (mkTyVarBinders Specified tyvars)- (mkTyVarBinders Specified ex_tyvars)+ tyvars ex_tyvars+ (mkTyVarBinders Specified user_tyvars) [] -- No equality spec [] -- No theta arg_tys (mkTyConApp tycon (mkTyVarTys tyvars))@@ -554,7 +556,7 @@ pcSpecialDataCon :: Name -> [Type] -> TyCon -> RuntimeRepInfo -> DataCon pcSpecialDataCon dc_name arg_tys tycon rri = pcDataConWithFixity' False dc_name (dataConWorkerUnique (nameUnique dc_name)) rri- [] [] arg_tys tycon+ [] [] [] arg_tys tycon {- ************************************************************************@@ -691,7 +693,7 @@ -- boxed tuple data/tycon "()" -> Just $ tup_name Boxed 0- _ | Just rest <- "(" `stripPrefix` name+ _ | Just rest <- "(" `BS.stripPrefix` name , (commas, rest') <- BS.span (==',') rest , ")" <- rest' -> Just $ tup_name Boxed (1+BS.length commas)@@ -699,21 +701,21 @@ -- unboxed tuple data/tycon "(##)" -> Just $ tup_name Unboxed 0 "Unit#" -> Just $ tup_name Unboxed 1- _ | Just rest <- "(#" `stripPrefix` name+ _ | Just rest <- "(#" `BS.stripPrefix` name , (commas, rest') <- BS.span (==',') rest , "#)" <- rest' -> Just $ tup_name Unboxed (1+BS.length commas) -- unboxed sum tycon- _ | Just rest <- "(#" `stripPrefix` name+ _ | Just rest <- "(#" `BS.stripPrefix` name , (pipes, rest') <- BS.span (=='|') rest , "#)" <- rest' -> Just $ tyConName $ sumTyCon (1+BS.length pipes) -- unboxed sum datacon- _ | Just rest <- "(#" `stripPrefix` name+ _ | Just rest <- "(#" `BS.stripPrefix` name , (pipes1, rest') <- BS.span (=='|') rest- , Just rest'' <- "_" `stripPrefix` rest'+ , Just rest'' <- "_" `BS.stripPrefix` rest' , (pipes2, rest''') <- BS.span (=='|') rest'' , "#)" <- rest''' -> let arity = BS.length pipes1 + BS.length pipes2 + 1@@ -721,15 +723,6 @@ in Just $ dataConName $ sumDataCon alt arity _ -> Nothing where- -- TODO: Drop when bytestring 0.10.8 can be assumed-#if MIN_VERSION_bytestring(0,10,8)- stripPrefix = BS.stripPrefix-#else- stripPrefix bs1@(BSI.PS _ _ l1) bs2- | bs1 `BS.isPrefixOf` bs2 = Just (BSU.unsafeDrop l1 bs2)- | otherwise = Nothing-#endif- name = fastStringToByteString $ occNameFS occ choose_ns :: Name -> Name -> Name@@ -1016,7 +1009,7 @@ ********************************************************************* -} -- See Note [The equality types story] in TysPrim--- (:~~: :: forall k1 k2 (a :: k1) (b :: k2). a -> b -> Constraint)+-- ((~~) :: forall k1 k2 (a :: k1) (b :: k2). a -> b -> Constraint) -- -- It's tempting to put functional dependencies on (~~), but it's not -- necessary because the functional-dependency coverage check looks@@ -1081,7 +1074,7 @@ liftedTypeKindTyCon, starKindTyCon, unicodeStarKindTyCon :: TyCon --- Type syononyms; see Note [TYPE and RuntimeRep] in TysPrim+-- Type synonyms; see Note [TYPE and RuntimeRep] in TysPrim -- type Type = tYPE 'LiftedRep -- type * = tYPE 'LiftedRep -- type * = tYPE 'LiftedRep -- Unicode variant@@ -1429,7 +1422,8 @@ consDataCon :: DataCon consDataCon = pcDataConWithFixity True {- Declared infix -} consDataConName- alpha_tyvar [] [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon+ alpha_tyvar [] alpha_tyvar+ [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon -- Interesting: polymorphic recursion would help here. -- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy -- gets the over-specific type (Type -> Type)
profiling/CostCentre.hs view
@@ -4,9 +4,9 @@ -- All abstract except to friend: ParseIface.y CostCentreStack,- CollectedCCs,- noCCS, currentCCS, dontCareCCS,- noCCSAttached, isCurrentCCS,+ CollectedCCs, emptyCollectedCCs, collectCC,+ currentCCS, dontCareCCS,+ isCurrentCCS, maybeSingletonCCS, mkUserCC, mkAutoCC, mkAllCafsCC,@@ -20,6 +20,8 @@ cmpCostCentre -- used for removing dups in a list ) where +import GhcPrelude+ import Binary import Var import Name@@ -158,9 +160,7 @@ -- pre-defined CCSs, see below). data CostCentreStack- = NoCCS-- | CurrentCCS -- Pinned on a let(rec)-bound+ = CurrentCCS -- Pinned on a let(rec)-bound -- thunk/function/constructor, this says that the -- cost centre to be attached to the object, when it -- is allocated, is whatever is in the@@ -180,24 +180,23 @@ -- code for a module. type CollectedCCs = ( [CostCentre] -- local cost-centres that need to be decl'd- , [CostCentre] -- "extern" cost-centres , [CostCentreStack] -- pre-defined "singleton" cost centre stacks ) +emptyCollectedCCs :: CollectedCCs+emptyCollectedCCs = ([], []) -noCCS, currentCCS, dontCareCCS :: CostCentreStack+collectCC :: CostCentre -> CostCentreStack -> CollectedCCs -> CollectedCCs+collectCC cc ccs (c, cs) = (cc : c, ccs : cs) -noCCS = NoCCS+currentCCS, dontCareCCS :: CostCentreStack+ currentCCS = CurrentCCS dontCareCCS = DontCareCCS ----------------------------------------------------------------------------- -- Predicates on Cost-Centre Stacks -noCCSAttached :: CostCentreStack -> Bool-noCCSAttached NoCCS = True-noCCSAttached _ = False- isCurrentCCS :: CostCentreStack -> Bool isCurrentCCS CurrentCCS = True isCurrentCCS _ = False@@ -221,7 +220,6 @@ -- expression. instance Outputable CostCentreStack where- ppr NoCCS = text "NO_CCS" ppr CurrentCCS = text "CCCS" ppr DontCareCCS = text "CCS_DONT_CARE" ppr (SingletonCCS cc) = ppr cc <> text "_ccs"@@ -255,9 +253,9 @@ cc_is_caf = caf}) = text "__scc" <+> braces (hsep [ ppr m <> char '.' <> ftext n,- ifPprDebug (ppr key),+ whenPprDebug (ppr key), pp_caf caf,- ifPprDebug (ppr loc)+ whenPprDebug (ppr loc) ]) pp_caf :: IsCafCC -> SDoc
profiling/ProfInit.hs view
@@ -8,11 +8,12 @@ module ProfInit (profilingInitCode) where +import GhcPrelude+ import CLabel import CostCentre import DynFlags import Outputable-import FastString import Module -- -----------------------------------------------------------------------------@@ -22,25 +23,42 @@ -- module; profilingInitCode :: Module -> CollectedCCs -> SDoc-profilingInitCode this_mod (local_CCs, ___extern_CCs, singleton_CCSs)+profilingInitCode this_mod (local_CCs, singleton_CCSs) = sdocWithDynFlags $ \dflags -> if not (gopt Opt_SccProfilingOn dflags) then empty else vcat- [ text "static void prof_init_" <> ppr this_mod- <> text "(void) __attribute__((constructor));"- , text "static void prof_init_" <> ppr this_mod <> text "(void)"- , braces (vcat (- map emitRegisterCC local_CCs ++- map emitRegisterCCS singleton_CCSs- ))- ]+ $ map emit_cc_decl local_CCs+ ++ map emit_ccs_decl singleton_CCSs+ ++ [emit_cc_list local_CCs]+ ++ [emit_ccs_list singleton_CCSs]+ ++ [ text "static void prof_init_" <> ppr this_mod+ <> text "(void) __attribute__((constructor));"+ , text "static void prof_init_" <> ppr this_mod <> text "(void)"+ , braces (vcat+ [ text "registerCcList" <> parens local_cc_list_label <> semi+ , text "registerCcsList" <> parens singleton_cc_list_label <> semi+ ])+ ] where- emitRegisterCC cc =- text "extern CostCentre " <> cc_lbl <> ptext (sLit "[];") $$- text "REGISTER_CC(" <> cc_lbl <> char ')' <> semi+ emit_cc_decl cc =+ text "extern CostCentre" <+> cc_lbl <> text "[];" where cc_lbl = ppr (mkCCLabel cc)- emitRegisterCCS ccs =- text "extern CostCentreStack " <> ccs_lbl <> ptext (sLit "[];") $$- text "REGISTER_CCS(" <> ccs_lbl <> char ')' <> semi+ local_cc_list_label = text "local_cc_" <> ppr this_mod+ emit_cc_list ccs =+ text "static CostCentre *" <> local_cc_list_label <> text "[] ="+ <+> braces (vcat $ [ ppr (mkCCLabel cc) <> comma+ | cc <- ccs+ ] ++ [text "NULL"])+ <> semi++ emit_ccs_decl ccs =+ text "extern CostCentreStack" <+> ccs_lbl <> text "[];" where ccs_lbl = ppr (mkCCSLabel ccs)+ singleton_cc_list_label = text "singleton_cc_" <> ppr this_mod+ emit_ccs_list ccs =+ text "static CostCentreStack *" <> singleton_cc_list_label <> text "[] ="+ <+> braces (vcat $ [ ppr (mkCCSLabel cc) <> comma+ | cc <- ccs+ ] ++ [text "NULL"])+ <> semi
− profiling/SCCfinal.hs
@@ -1,285 +0,0 @@--- (c) The GRASP/AQUA Project, Glasgow University, 1992-1998-{-# LANGUAGE CPP #-}---------------------------------------------------------------------------------- Modify and collect code generation for final STG program--{-- This is now a sort-of-normal STG-to-STG pass (WDP 94/06), run by stg2stg.-- - Traverses the STG program collecting the cost centres. These are required- to declare the cost centres at the start of code generation.-- Note: because of cross-module unfolding, some of these cost centres may be- from other modules.-- - Puts on CAF cost-centres if the user has asked for individual CAF- cost-centres.--}--module SCCfinal ( stgMassageForProfiling ) where--#include "HsVersions.h"--import StgSyn--import CostCentre -- lots of things-import Id-import Name-import Module-import UniqSupply ( UniqSupply )-import ListSetOps ( removeDups )-import Outputable-import DynFlags-import CoreSyn ( Tickish(..) )-import FastString-import SrcLoc-import Util--import Control.Monad (liftM, ap)--stgMassageForProfiling- :: DynFlags- -> Module -- module name- -> UniqSupply -- unique supply- -> [StgTopBinding] -- input- -> (CollectedCCs, [StgTopBinding])--stgMassageForProfiling dflags mod_name _us stg_binds- = let- ((local_ccs, extern_ccs, cc_stacks),- stg_binds2)- = initMM mod_name (do_top_bindings stg_binds)-- (fixed_ccs, fixed_cc_stacks)- = if gopt Opt_AutoSccsOnIndividualCafs dflags- then ([],[]) -- don't need "all CAFs" CC- else ([all_cafs_cc], [all_cafs_ccs])-- local_ccs_no_dups = fst (removeDups cmpCostCentre local_ccs)- extern_ccs_no_dups = fst (removeDups cmpCostCentre extern_ccs)- in- ((fixed_ccs ++ local_ccs_no_dups,- extern_ccs_no_dups,- fixed_cc_stacks ++ cc_stacks), stg_binds2)- where-- span = mkGeneralSrcSpan (mkFastString "<entire-module>") -- XXX do better- all_cafs_cc = mkAllCafsCC mod_name span- all_cafs_ccs = mkSingletonCCS all_cafs_cc-- ----------- do_top_bindings :: [StgTopBinding] -> MassageM [StgTopBinding]-- do_top_bindings [] = return []-- do_top_bindings (StgTopLifted (StgNonRec b rhs) : bs) = do- rhs' <- do_top_rhs b rhs- bs' <- do_top_bindings bs- return (StgTopLifted (StgNonRec b rhs') : bs')-- do_top_bindings (StgTopLifted (StgRec pairs) : bs) = do- pairs2 <- mapM do_pair pairs- bs' <- do_top_bindings bs- return (StgTopLifted (StgRec pairs2) : bs')- where- do_pair (b, rhs) = do- rhs2 <- do_top_rhs b rhs- return (b, rhs2)-- do_top_bindings (b@StgTopStringLit{} : bs) = do- bs' <- do_top_bindings bs- return (b : bs')-- ----------- do_top_rhs :: Id -> StgRhs -> MassageM StgRhs-- do_top_rhs _ (StgRhsClosure _ _ _ _ []- (StgTick (ProfNote _cc False{-not tick-} _push)- (StgConApp con args _)))- | not (isDllConApp dflags mod_name con args)- -- Trivial _scc_ around nothing but static data- -- Eliminate _scc_ ... and turn into StgRhsCon-- -- isDllConApp checks for LitLit args too- = return (StgRhsCon dontCareCCS con args)-- do_top_rhs binder (StgRhsClosure _ bi fv u [] body)- = do- -- Top level CAF without a cost centre attached- -- Attach CAF cc (collect if individual CAF ccs)- caf_ccs <- if gopt Opt_AutoSccsOnIndividualCafs dflags- then let cc = mkAutoCC binder modl CafCC- ccs = mkSingletonCCS cc- -- careful: the binder might be :Main.main,- -- which doesn't belong to module mod_name.- -- bug #249, tests prof001, prof002- modl | Just m <- nameModule_maybe (idName binder) = m- | otherwise = mod_name- in do- collectNewCC cc- collectCCS ccs- return ccs- else- return all_cafs_ccs- body' <- do_expr body- return (StgRhsClosure caf_ccs bi fv u [] body')-- do_top_rhs _ (StgRhsClosure _no_ccs bi fv u args body)- = do body' <- do_expr body- return (StgRhsClosure dontCareCCS bi fv u args body')-- do_top_rhs _ (StgRhsCon _ con args)- -- Top-level (static) data is not counted in heap- -- profiles; nor do we set CCCS from it; so we- -- just slam in dontCareCostCentre- = return (StgRhsCon dontCareCCS con args)-- ------- do_expr :: StgExpr -> MassageM StgExpr-- do_expr (StgLit l) = return (StgLit l)-- do_expr (StgApp fn args)- = return (StgApp fn args)-- do_expr (StgConApp con args ty_args)- = return (StgConApp con args ty_args)-- do_expr (StgOpApp con args res_ty)- = return (StgOpApp con args res_ty)-- do_expr (StgTick note@(ProfNote cc _ _) expr) = do- -- Ha, we found a cost centre!- collectCC cc- expr' <- do_expr expr- return (StgTick note expr')-- do_expr (StgTick ti expr) = do- expr' <- do_expr expr- return (StgTick ti expr')-- do_expr (StgCase expr bndr alt_type alts) = do- expr' <- do_expr expr- alts' <- mapM do_alt alts- return (StgCase expr' bndr alt_type alts')- where- do_alt (id, bs, e) = do- e' <- do_expr e- return (id, bs, e')-- do_expr (StgLet b e) = do- (b,e) <- do_let b e- return (StgLet b e)-- do_expr (StgLetNoEscape b e) = do- (b,e) <- do_let b e- return (StgLetNoEscape b e)-- do_expr other = pprPanic "SCCfinal.do_expr" (ppr other)-- ------------------------------------ do_let (StgNonRec b rhs) e = do- rhs' <- do_rhs rhs- e' <- do_expr e- return (StgNonRec b rhs',e')-- do_let (StgRec pairs) e = do- pairs' <- mapM do_pair pairs- e' <- do_expr e- return (StgRec pairs', e')- where- do_pair (b, rhs) = do- rhs2 <- do_rhs rhs- return (b, rhs2)-- ----------------------------------- do_rhs :: StgRhs -> MassageM StgRhs- -- We play much the same game as we did in do_top_rhs above;- -- but we don't have to worry about cafs etc.-- -- throw away the SCC if we don't have to count entries. This- -- is a little bit wrong, because we're attributing the- -- allocation of the constructor to the wrong place (XXX)- -- We should really attach (PushCC cc CurrentCCS) to the rhs,- -- but need to reinstate PushCC for that.- do_rhs (StgRhsClosure _closure_cc _bi _fv _u []- (StgTick (ProfNote cc False{-not tick-} _push)- (StgConApp con args _)))- = do collectCC cc- return (StgRhsCon currentCCS con args)-- do_rhs (StgRhsClosure _ bi fv u args expr) = do- expr' <- do_expr expr- return (StgRhsClosure currentCCS bi fv u args expr')-- do_rhs (StgRhsCon _ con args)- = return (StgRhsCon currentCCS con args)----- -------------------------------------------------------------------------------- Boring monad stuff for this--newtype MassageM result- = MassageM {- unMassageM :: Module -- module name- -> CollectedCCs- -> (CollectedCCs, result)- }--instance Functor MassageM where- fmap = liftM--instance Applicative MassageM where- pure x = MassageM (\_ ccs -> (ccs, x))- (<*>) = ap- (*>) = thenMM_--instance Monad MassageM where- (>>=) = thenMM- (>>) = (*>)---- the initMM function also returns the final CollectedCCs--initMM :: Module -- module name, which we may consult- -> MassageM a- -> (CollectedCCs, a)--initMM mod_name (MassageM m) = m mod_name ([],[],[])--thenMM :: MassageM a -> (a -> MassageM b) -> MassageM b-thenMM_ :: MassageM a -> (MassageM b) -> MassageM b--thenMM expr cont = MassageM $ \mod ccs ->- case unMassageM expr mod ccs of { (ccs2, result) ->- unMassageM (cont result) mod ccs2 }--thenMM_ expr cont = MassageM $ \mod ccs ->- case unMassageM expr mod ccs of { (ccs2, _) ->- unMassageM cont mod ccs2 }---collectCC :: CostCentre -> MassageM ()-collectCC cc- = MassageM $ \mod_name (local_ccs, extern_ccs, ccss)- -> if (cc `ccFromThisModule` mod_name) then- ((cc : local_ccs, extern_ccs, ccss), ())- else -- must declare it "extern"- ((local_ccs, cc : extern_ccs, ccss), ())---- Version of collectCC used when we definitely want to declare this--- CC as local, even if its module name is not the same as the current--- module name (eg. the special :Main module) see bug #249, #1472,--- test prof001,prof002.-collectNewCC :: CostCentre -> MassageM ()-collectNewCC cc- = MassageM $ \_mod_name (local_ccs, extern_ccs, ccss)- -> ((cc : local_ccs, extern_ccs, ccss), ())--collectCCS :: CostCentreStack -> MassageM ()--collectCCS ccs- = MassageM $ \_mod_name (local_ccs, extern_ccs, ccss)- -> ASSERT(not (noCCSAttached ccs))- ((local_ccs, extern_ccs, ccs : ccss), ())
rename/RnBinds.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE ScopedTypeVariables, BangPatterns #-}+{-# LANGUAGE TypeFamilies #-} {- (c) The GRASP/AQUA Project, Glasgow University, 1992-1998@@ -20,11 +21,13 @@ -- Other bindings rnMethodBinds, renameSigs,- rnMatchGroup, rnGRHSs, rnGRHS,+ rnMatchGroup, rnGRHSs, rnGRHS, rnSrcFixityDecl, makeMiniFixityEnv, MiniFixityEnv, HsSigCtxt(..) ) where +import GhcPrelude+ import {-# SOURCE #-} RnExpr( rnLExpr, rnStmts ) import HsSyn@@ -34,6 +37,10 @@ import RnPat import RnNames import RnEnv+import RnFixity+import RnUtils ( HsDocContext(..), mapFvRn, extendTyVarEnvFVRn+ , checkDupRdrNames, warnUnusedLocalBinds+ , checkDupAndShadowedNames, bindLocalNamesFV ) import DynFlags import Module import Name@@ -42,18 +49,19 @@ import RdrName ( RdrName, rdrNameOcc ) import SrcLoc import ListSetOps ( findDupsEq )-import BasicTypes ( RecFlag(..), LexicalFixity(..) )+import BasicTypes ( RecFlag(..) ) import Digraph ( SCC(..) ) import Bag import Util import Outputable-import FastString import UniqSet import Maybes ( orElse ) import qualified GHC.LanguageExtensions as LangExt import Control.Monad-import Data.List ( partition, sort )+import Data.Foldable ( toList )+import Data.List ( partition, sort )+import Data.List.NonEmpty ( NonEmpty(..) ) {- -- ToDo: Put the annotations into the monad, so that they arrive in the proper@@ -166,12 +174,13 @@ -- for top-level bindings, we need to make top-level names, -- so we have a different entry point than for local bindings rnTopBindsLHS :: MiniFixityEnv- -> HsValBinds RdrName- -> RnM (HsValBindsLR Name RdrName)+ -> HsValBinds GhcPs+ -> RnM (HsValBindsLR GhcRn GhcPs) rnTopBindsLHS fix_env binds = rnValBindsLHS (topRecNameMaker fix_env) binds -rnTopBindsBoot :: NameSet -> HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)+rnTopBindsBoot :: NameSet -> HsValBindsLR GhcRn GhcPs+ -> RnM (HsValBinds GhcRn, DefUses) -- A hs-boot file has no bindings. -- Return a single HsBindGroup with empty binds and renamed signatures rnTopBindsBoot bound_names (ValBindsIn mbinds sigs)@@ -188,9 +197,9 @@ ********************************************************* -} -rnLocalBindsAndThen :: HsLocalBinds RdrName- -> (HsLocalBinds Name -> FreeVars -> RnM (result, FreeVars))- -> RnM (result, FreeVars)+rnLocalBindsAndThen :: HsLocalBinds GhcPs+ -> (HsLocalBinds GhcRn -> FreeVars -> RnM (result, FreeVars))+ -> RnM (result, FreeVars) -- This version (a) assumes that the binding vars are *not* already in scope -- (b) removes the binders from the free vars of the thing inside -- The parser doesn't produce ThenBinds@@ -206,12 +215,12 @@ (thing, fvs_thing) <- thing_inside (HsIPBinds binds') fv_binds return (thing, fvs_thing `plusFV` fv_binds) -rnIPBinds :: HsIPBinds RdrName -> RnM (HsIPBinds Name, FreeVars)+rnIPBinds :: HsIPBinds GhcPs -> RnM (HsIPBinds GhcRn, FreeVars) rnIPBinds (IPBinds ip_binds _no_dict_binds) = do (ip_binds', fvs_s) <- mapAndUnzipM (wrapLocFstM rnIPBind) ip_binds return (IPBinds ip_binds' emptyTcEvBinds, plusFVs fvs_s) -rnIPBind :: IPBind RdrName -> RnM (IPBind Name, FreeVars)+rnIPBind :: IPBind GhcPs -> RnM (IPBind GhcRn, FreeVars) rnIPBind (IPBind ~(Left n) expr) = do (expr',fvExpr) <- rnLExpr expr return (IPBind (Left n) expr', fvExpr)@@ -227,8 +236,8 @@ -- Renaming local binding groups -- Does duplicate/shadow check rnLocalValBindsLHS :: MiniFixityEnv- -> HsValBinds RdrName- -> RnM ([Name], HsValBindsLR Name RdrName)+ -> HsValBinds GhcPs+ -> RnM ([Name], HsValBindsLR GhcRn GhcPs) rnLocalValBindsLHS fix_env binds = do { binds' <- rnValBindsLHS (localRecNameMaker fix_env) binds @@ -263,8 +272,8 @@ -- generic version used both at the top level and for local binds -- does some error checking, but not what gets done elsewhere at the top level rnValBindsLHS :: NameMaker- -> HsValBinds RdrName- -> RnM (HsValBindsLR Name RdrName)+ -> HsValBinds GhcPs+ -> RnM (HsValBindsLR GhcRn GhcPs) rnValBindsLHS topP (ValBindsIn mbinds sigs) = do { mbinds' <- mapBagM (wrapLocM (rnBindLHS topP doc)) mbinds ; return $ ValBindsIn mbinds' sigs }@@ -279,8 +288,8 @@ -- -- Does not bind the local fixity declarations rnValBindsRHS :: HsSigCtxt- -> HsValBindsLR Name RdrName- -> RnM (HsValBinds Name, DefUses)+ -> HsValBindsLR GhcRn GhcPs+ -> RnM (HsValBinds GhcRn, DefUses) rnValBindsRHS ctxt (ValBindsIn mbinds sigs) = do { (sigs', sig_fvs) <- renameSigs ctxt sigs@@ -313,8 +322,8 @@ -- -- The client is also responsible for bringing the fixities into scope rnLocalValBindsRHS :: NameSet -- names bound by the LHSes- -> HsValBindsLR Name RdrName- -> RnM (HsValBinds Name, DefUses)+ -> HsValBindsLR GhcRn GhcPs+ -> RnM (HsValBinds GhcRn, DefUses) rnLocalValBindsRHS bound_names binds = rnValBindsRHS (LocalBindCtxt bound_names) binds @@ -324,8 +333,8 @@ -- here there are no local fixity decls passed in; -- the local fixity decls come from the ValBinds sigs rnLocalValBindsAndThen- :: HsValBinds RdrName- -> (HsValBinds Name -> FreeVars -> RnM (result, FreeVars))+ :: HsValBinds GhcPs+ -> (HsValBinds GhcRn -> FreeVars -> RnM (result, FreeVars)) -> RnM (result, FreeVars) rnLocalValBindsAndThen binds@(ValBindsIn _ sigs) thing_inside = do { -- (A) Create the local fixity environment@@ -386,11 +395,11 @@ rnBindLHS :: NameMaker -> SDoc- -> HsBind RdrName+ -> HsBind GhcPs -- returns the renamed left-hand side, -- and the FreeVars *of the LHS* -- (i.e., any free variables of the pattern)- -> RnM (HsBindLR Name RdrName)+ -> RnM (HsBindLR GhcRn GhcPs) rnBindLHS name_maker _ bind@(PatBind { pat_lhs = pat }) = do@@ -425,18 +434,18 @@ rnBindLHS _ _ b = pprPanic "rnBindHS" (ppr b) -rnLBind :: (Name -> [Name]) -- Signature tyvar function- -> LHsBindLR Name RdrName- -> RnM (LHsBind Name, [Name], Uses)+rnLBind :: (Name -> [Name]) -- Signature tyvar function+ -> LHsBindLR GhcRn GhcPs+ -> RnM (LHsBind GhcRn, [Name], Uses) rnLBind sig_fn (L loc bind) = setSrcSpan loc $ do { (bind', bndrs, dus) <- rnBind sig_fn bind ; return (L loc bind', bndrs, dus) } -- assumes the left-hands-side vars are in scope-rnBind :: (Name -> [Name]) -- Signature tyvar function- -> HsBindLR Name RdrName- -> RnM (HsBind Name, [Name], Uses)+rnBind :: (Name -> [Name]) -- Signature tyvar function+ -> HsBindLR GhcRn GhcPs+ -> RnM (HsBind GhcRn, [Name], Uses) rnBind _ bind@(PatBind { pat_lhs = pat , pat_rhs = grhss -- pat fvs were stored in bind_fvs@@ -452,21 +461,22 @@ -- As well as dependency analysis, we need these for the -- MonoLocalBinds test in TcBinds.decideGeneralisationPlan bndrs = collectPatBinders pat- bind' = bind { pat_rhs = grhss',- pat_rhs_ty = placeHolderType, bind_fvs = fvs' }- is_wild_pat = case pat of- L _ (WildPat {}) -> True- L _ (BangPat (L _ (WildPat {}))) -> True -- #9127- _ -> False+ bind' = bind { pat_rhs = grhss'+ , pat_rhs_ty = placeHolderType, bind_fvs = fvs' } - -- Warn if the pattern binds no variables, except for the- -- entirely-explicit idiom _ = rhs- -- which (a) is not that different from _v = rhs- -- (b) is sometimes used to give a type sig for,- -- or an occurrence of, a variable on the RHS+ ok_nobind_pat+ = -- See Note [Pattern bindings that bind no variables]+ case pat of+ L _ (WildPat {}) -> True+ L _ (BangPat {}) -> True -- #9127, #13646+ _ -> False++ -- Warn if the pattern binds no variables+ -- See Note [Pattern bindings that bind no variables] ; whenWOptM Opt_WarnUnusedPatternBinds $- when (null bndrs && not is_wild_pat) $- addWarn (Reason Opt_WarnUnusedPatternBinds) $ unusedPatBindWarn bind'+ when (null bndrs && not ok_nobind_pat) $+ addWarn (Reason Opt_WarnUnusedPatternBinds) $+ unusedPatBindWarn bind' ; fvs' `seq` -- See Note [Free-variable space leak] return (bind', bndrs, all_fvs) }@@ -501,7 +511,24 @@ rnBind _ b = pprPanic "rnBind" (ppr b) -{-+{- Note [Pattern bindings that bind no variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Generally, we want to warn about pattern bindings like+ Just _ = e+because they don't do anything! But we have two exceptions:++* A wildcard pattern+ _ = rhs+ which (a) is not that different from _v = rhs+ (b) is sometimes used to give a type sig for,+ or an occurrence of, a variable on the RHS++* A strict pattern binding; that is, one with an outermost bang+ !Just _ = e+ This can fail, so unlike the lazy variant, it is not a no-op.+ Moreover, Trac #13646 argues that even for single constructor+ types, you might want to write the constructor. See also #9127.+ Note [Free-variable space leak] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We have@@ -520,8 +547,8 @@ * * ********************************************************************* -} -depAnalBinds :: Bag (LHsBind Name, [Name], Uses)- -> ([(RecFlag, LHsBinds Name)], DefUses)+depAnalBinds :: Bag (LHsBind GhcRn, [Name], Uses)+ -> ([(RecFlag, LHsBinds GhcRn)], DefUses) -- Dependency analysis; this is important so that -- unused-binding reporting is accurate depAnalBinds binds_w_dus@@ -555,14 +582,14 @@ -- (x,y) = e -- In e, 'a' will be in scope, and it'll be the one from 'y'! -mkSigTvFn :: [LSig Name] -> (Name -> [Name])+mkSigTvFn :: [LSig GhcRn] -> (Name -> [Name]) -- Return a lookup function that maps an Id Name to the names -- of the type variables that should scope over its body. mkSigTvFn sigs = \n -> lookupNameEnv env n `orElse` [] where env = mkHsSigEnv get_scoped_tvs sigs - get_scoped_tvs :: LSig Name -> Maybe ([Located Name], [Name])+ get_scoped_tvs :: LSig GhcRn -> Maybe ([Located Name], [Name]) -- Returns (binders, scoped tvs for those binders) get_scoped_tvs (L _ (ClassOpSig _ names sig_ty)) = Just (names, hsScopedTvs sig_ty)@@ -579,7 +606,7 @@ -- Note: for local fixity declarations, duplicates would also be checked in -- check_sigs below. But we also use this function at the top level. -makeMiniFixityEnv :: [LFixitySig RdrName] -> RnM MiniFixityEnv+makeMiniFixityEnv :: [LFixitySig GhcPs] -> RnM MiniFixityEnv makeMiniFixityEnv decls = foldlM add_one_sig emptyFsEnv decls where@@ -615,9 +642,9 @@ * * ********************************************************************* -} -rnPatSynBind :: (Name -> [Name]) -- Signature tyvar function- -> PatSynBind Name RdrName- -> RnM (PatSynBind Name Name, [Name], Uses)+rnPatSynBind :: (Name -> [Name]) -- Signature tyvar function+ -> PatSynBind GhcRn GhcPs+ -> RnM (PatSynBind GhcRn GhcRn, [Name], Uses) rnPatSynBind sig_fn bind@(PSB { psb_id = L l name , psb_args = details , psb_def = pat@@ -633,29 +660,29 @@ -- so that the binding locations are reported -- from the left-hand side case details of- PrefixPatSyn vars ->+ PrefixCon vars -> do { checkDupRdrNames vars- ; names <- mapM lookupVar vars- ; return ( (pat', PrefixPatSyn names)+ ; names <- mapM lookupPatSynBndr vars+ ; return ( (pat', PrefixCon names) , mkFVs (map unLoc names)) }- InfixPatSyn var1 var2 ->+ InfixCon var1 var2 -> do { checkDupRdrNames [var1, var2]- ; name1 <- lookupVar var1- ; name2 <- lookupVar var2+ ; name1 <- lookupPatSynBndr var1+ ; name2 <- lookupPatSynBndr var2 -- ; checkPrecMatch -- TODO- ; return ( (pat', InfixPatSyn name1 name2)+ ; return ( (pat', InfixCon name1 name2) , mkFVs (map unLoc [name1, name2])) }- RecordPatSyn vars ->+ RecCon vars -> do { checkDupRdrNames (map recordPatSynSelectorId vars) ; let rnRecordPatSynField (RecordPatSynField { recordPatSynSelectorId = visible , recordPatSynPatVar = hidden }) = do { visible' <- lookupLocatedTopBndrRn visible- ; hidden' <- lookupVar hidden+ ; hidden' <- lookupPatSynBndr hidden ; return $ RecordPatSynField { recordPatSynSelectorId = visible' , recordPatSynPatVar = hidden' } } ; names <- mapM rnRecordPatSynField vars- ; return ( (pat', RecordPatSyn names)+ ; return ( (pat', RecCon names) , mkFVs (map (unLoc . recordPatSynPatVar) names)) } ; (dir', fvs2) <- case dir of@@ -679,7 +706,7 @@ , psb_dir = dir' , psb_fvs = fvs' } selector_names = case details' of- RecordPatSyn names ->+ RecCon names -> map (unLoc . recordPatSynSelectorId) names _ -> [] @@ -688,7 +715,8 @@ -- Why fvs1? See Note [Pattern synonym builders don't yield dependencies] } where- lookupVar = wrapLocM lookupOccRn+ -- See Note [Renaming pattern synonym variables]+ lookupPatSynBndr = wrapLocM lookupLocalOccRn patternSynonymErr :: SDoc patternSynonymErr@@ -696,6 +724,36 @@ 2 (text "Use -XPatternSynonyms to enable this extension") {-+Note [Renaming pattern synonym variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++We rename pattern synonym declaractions backwards to normal to reuse+the logic already implemented for renaming patterns.++We first rename the RHS of a declaration which brings into+scope the variables bound by the pattern (as they would be+in normal function definitions). We then lookup the variables+which we want to bind in this local environment.++It is crucial that we then only lookup in the *local* environment which+only contains the variables brought into scope by the pattern and nothing+else. Amazingly no-one encountered this bug for 3 GHC versions but+it was possible to define a pattern synonym which referenced global+identifiers and worked correctly.++```+x = 5++pattern P :: Int -> ()+pattern P x <- _++f (P x) = x++> f () = 5+```++See #13470 for the original report.+ Note [Pattern synonym builders don't yield dependencies] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ When renaming a pattern synonym that has an explicit builder,@@ -756,9 +814,9 @@ rnMethodBinds :: Bool -- True <=> is a class declaration -> Name -- Class name -> [Name] -- Type variables from the class/instance header- -> LHsBinds RdrName -- Binds- -> [LSig RdrName] -- and signatures/pragmas- -> RnM (LHsBinds Name, [LSig Name], FreeVars)+ -> LHsBinds GhcPs -- Binds+ -> [LSig GhcPs] -- and signatures/pragmas+ -> RnM (LHsBinds GhcRn, [LSig GhcRn], FreeVars) -- Used for -- * the default method bindings in a class decl -- * the method bindings in an instance decl@@ -811,9 +869,9 @@ | otherwise = thing_inside rnMethodBindLHS :: Bool -> Name- -> LHsBindLR RdrName RdrName- -> LHsBindsLR Name RdrName- -> RnM (LHsBindsLR Name RdrName)+ -> LHsBindLR GhcPs GhcPs+ -> LHsBindsLR GhcRn GhcPs+ -> RnM (LHsBindsLR GhcRn GhcPs) rnMethodBindLHS _ cls (L loc bind@(FunBind { fun_id = name })) rest = setSrcSpan loc $ do do { sel_name <- wrapLocM (lookupInstDeclBndr cls (text "method")) name@@ -857,8 +915,8 @@ -} renameSigs :: HsSigCtxt- -> [LSig RdrName]- -> RnM ([LSig Name], FreeVars)+ -> [LSig GhcPs]+ -> RnM ([LSig GhcRn], FreeVars) -- Renames the signatures and performs error checks renameSigs ctxt sigs = do { mapM_ dupSigDeclErr (findDupSigs sigs)@@ -882,8 +940,7 @@ -- is in scope. (I'm assuming that Baz.op isn't in scope unqualified.) -- Doesn't seem worth much trouble to sort this. -renameSig :: HsSigCtxt -> Sig RdrName -> RnM (Sig Name, FreeVars)--- FixitySig is renamed elsewhere.+renameSig :: HsSigCtxt -> Sig GhcPs -> RnM (Sig GhcRn, FreeVars) renameSig _ (IdSig x) = return (IdSig x, emptyFVs) -- Actually this never occurs @@ -930,9 +987,9 @@ = do { new_v <- lookupSigOccRn ctxt sig v ; return (InlineSig new_v s, emptyFVs) } -renameSig ctxt sig@(FixSig (FixitySig vs f))- = do { new_vs <- mapM (lookupSigOccRn ctxt sig) vs- ; return (FixSig (FixitySig new_vs f), emptyFVs) }+renameSig ctxt (FixSig fsig)+ = do { new_fsig <- rnSrcFixityDecl ctxt fsig+ ; return (FixSig new_fsig, emptyFVs) } renameSig ctxt sig@(MinimalSig s (L l bf)) = do new_bf <- traverse (lookupSigOccRn ctxt sig) bf@@ -1036,7 +1093,7 @@ (CompleteMatchSig {}, _) -> False --------------------findDupSigs :: [LSig RdrName] -> [[(Located RdrName, Sig RdrName)]]+findDupSigs :: [LSig GhcPs] -> [NonEmpty (Located RdrName, Sig GhcPs)] -- Check for duplicates on RdrName version, -- because renamed version has unboundName for -- not-in-scope binders, which gives bogus dup-sig errors@@ -1066,7 +1123,7 @@ mtch _ _ = False -- Warn about multiple MINIMAL signatures-checkDupMinimalSigs :: [LSig RdrName] -> RnM ()+checkDupMinimalSigs :: [LSig GhcPs] -> RnM () checkDupMinimalSigs sigs = case filter isMinimalLSig sigs of minSigs@(_:_:_) -> dupMinimalSigErr minSigs@@ -1080,44 +1137,36 @@ ************************************************************************ -} -rnMatchGroup :: Outputable (body RdrName) => HsMatchContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> MatchGroup RdrName (Located (body RdrName))- -> RnM (MatchGroup Name (Located (body Name)), FreeVars)+rnMatchGroup :: Outputable (body GhcPs) => HsMatchContext Name+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> MatchGroup GhcPs (Located (body GhcPs))+ -> RnM (MatchGroup GhcRn (Located (body GhcRn)), FreeVars) rnMatchGroup ctxt rnBody (MG { mg_alts = L _ ms, mg_origin = origin }) = do { empty_case_ok <- xoptM LangExt.EmptyCase ; when (null ms && not empty_case_ok) (addErr (emptyCaseErr ctxt)) ; (new_ms, ms_fvs) <- mapFvRn (rnMatch ctxt rnBody) ms ; return (mkMatchGroup origin new_ms, ms_fvs) } -rnMatch :: Outputable (body RdrName) => HsMatchContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> LMatch RdrName (Located (body RdrName))- -> RnM (LMatch Name (Located (body Name)), FreeVars)+rnMatch :: Outputable (body GhcPs) => HsMatchContext Name+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> LMatch GhcPs (Located (body GhcPs))+ -> RnM (LMatch GhcRn (Located (body GhcRn)), FreeVars) rnMatch ctxt rnBody = wrapLocFstM (rnMatch' ctxt rnBody) -rnMatch' :: Outputable (body RdrName) => HsMatchContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> Match RdrName (Located (body RdrName))- -> RnM (Match Name (Located (body Name)), FreeVars)-rnMatch' ctxt rnBody match@(Match { m_ctxt = mf, m_pats = pats- , m_type = maybe_rhs_sig, m_grhss = grhss })- = do { -- Result type signatures are no longer supported- case maybe_rhs_sig of- Nothing -> return ()- Just (L loc ty) -> addErrAt loc (resSigErr match ty)-- ; let fixity = if isInfixMatch match then Infix else Prefix- -- Now the main event- -- Note that there are no local fixity decls for matches+rnMatch' :: Outputable (body GhcPs) => HsMatchContext Name+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> Match GhcPs (Located (body GhcPs))+ -> RnM (Match GhcRn (Located (body GhcRn)), FreeVars)+rnMatch' ctxt rnBody (Match { m_ctxt = mf, m_pats = pats, m_grhss = grhss })+ = do { -- Note that there are no local fixity decls for matches ; rnPats ctxt pats $ \ pats' -> do { (grhss', grhss_fvs) <- rnGRHSs ctxt rnBody grhss- ; let mf' = case (ctxt,mf) of- (FunRhs (L _ funid) _ _,FunRhs (L lf _) _ strict)- -> FunRhs (L lf funid) fixity strict+ ; let mf' = case (ctxt, mf) of+ (FunRhs { mc_fun = L _ funid }, FunRhs { mc_fun = L lf _ })+ -> mf { mc_fun = L lf funid } _ -> ctxt ; return (Match { m_ctxt = mf', m_pats = pats'- , m_type = Nothing, m_grhss = grhss'}, grhss_fvs ) }}+ , m_grhss = grhss'}, grhss_fvs ) }} emptyCaseErr :: HsMatchContext Name -> SDoc emptyCaseErr ctxt = hang (text "Empty list of alternatives in" <+> pp_ctxt)@@ -1128,15 +1177,6 @@ LambdaExpr -> text "\\case expression" _ -> text "(unexpected)" <+> pprMatchContextNoun ctxt --resSigErr :: Outputable body- => Match RdrName body -> HsType RdrName -> SDoc-resSigErr match ty- = vcat [ text "Illegal result type signature" <+> quotes (ppr ty)- , nest 2 $ ptext (sLit- "Result signatures are no longer supported in pattern matches")- , pprMatchInCtxt match ]- {- ************************************************************************ * *@@ -1146,24 +1186,24 @@ -} rnGRHSs :: HsMatchContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> GRHSs RdrName (Located (body RdrName))- -> RnM (GRHSs Name (Located (body Name)), FreeVars)+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> GRHSs GhcPs (Located (body GhcPs))+ -> RnM (GRHSs GhcRn (Located (body GhcRn)), FreeVars) rnGRHSs ctxt rnBody (GRHSs grhss (L l binds)) = rnLocalBindsAndThen binds $ \ binds' _ -> do (grhss', fvGRHSs) <- mapFvRn (rnGRHS ctxt rnBody) grhss return (GRHSs grhss' (L l binds'), fvGRHSs) rnGRHS :: HsMatchContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> LGRHS RdrName (Located (body RdrName))- -> RnM (LGRHS Name (Located (body Name)), FreeVars)+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> LGRHS GhcPs (Located (body GhcPs))+ -> RnM (LGRHS GhcRn (Located (body GhcRn)), FreeVars) rnGRHS ctxt rnBody = wrapLocFstM (rnGRHS' ctxt rnBody) rnGRHS' :: HsMatchContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> GRHS RdrName (Located (body RdrName))- -> RnM (GRHS Name (Located (body Name)), FreeVars)+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> GRHS GhcPs (Located (body GhcPs))+ -> RnM (GRHS GhcRn (Located (body GhcRn)), FreeVars) rnGRHS' ctxt rnBody (GRHS guards rhs) = do { pattern_guards_allowed <- xoptM LangExt.PatternGuards ; ((guards', rhs'), fvs) <- rnStmts (PatGuard ctxt) rnLExpr guards $ \ _ ->@@ -1182,6 +1222,38 @@ is_standard_guard _ = False {-+*********************************************************+* *+ Source-code fixity declarations+* *+*********************************************************+-}++rnSrcFixityDecl :: HsSigCtxt -> FixitySig GhcPs -> RnM (FixitySig GhcRn)+-- Rename a fixity decl, so we can put+-- the renamed decl in the renamed syntax tree+-- Errors if the thing being fixed is not defined locally.+rnSrcFixityDecl sig_ctxt = rn_decl+ where+ rn_decl :: FixitySig GhcPs -> RnM (FixitySig GhcRn)+ -- GHC extension: look up both the tycon and data con+ -- for con-like things; hence returning a list+ -- If neither are in scope, report an error; otherwise+ -- return a fixity sig for each (slightly odd)+ rn_decl (FixitySig fnames fixity)+ = do names <- concatMapM lookup_one fnames+ return (FixitySig names fixity)++ lookup_one :: Located RdrName -> RnM [Located Name]+ lookup_one (L name_loc rdr_name)+ = setSrcSpan name_loc $+ -- This lookup will fail if the name is not defined in the+ -- same binding group as this fixity declaration.+ do names <- lookupLocalTcNames sig_ctxt what rdr_name+ return [ L name_loc name | (_, name) <- names ]+ what = text "fixity signature"++{- ************************************************************************ * * \subsection{Error messages}@@ -1189,43 +1261,44 @@ ************************************************************************ -} -dupSigDeclErr :: [(Located RdrName, Sig RdrName)] -> RnM ()-dupSigDeclErr pairs@((L loc name, sig) : _)+dupSigDeclErr :: NonEmpty (Located RdrName, Sig GhcPs) -> RnM ()+dupSigDeclErr pairs@((L loc name, sig) :| _) = addErrAt loc $ vcat [ text "Duplicate" <+> what_it_is <> text "s for" <+> quotes (ppr name)- , text "at" <+> vcat (map ppr $ sort $ map (getLoc . fst) pairs) ]+ , text "at" <+> vcat (map ppr $ sort+ $ map (getLoc . fst)+ $ toList pairs)+ ] where what_it_is = hsSigDoc sig -dupSigDeclErr [] = panic "dupSigDeclErr"--misplacedSigErr :: LSig Name -> RnM ()+misplacedSigErr :: LSig GhcRn -> RnM () misplacedSigErr (L loc sig) = addErrAt loc $ sep [text "Misplaced" <+> hsSigDoc sig <> colon, ppr sig] -defaultSigErr :: Sig RdrName -> SDoc+defaultSigErr :: Sig GhcPs -> SDoc defaultSigErr sig = vcat [ hang (text "Unexpected default signature:") 2 (ppr sig) , text "Use DefaultSignatures to enable default signatures" ] -bindsInHsBootFile :: LHsBindsLR Name RdrName -> SDoc+bindsInHsBootFile :: LHsBindsLR GhcRn GhcPs -> SDoc bindsInHsBootFile mbinds = hang (text "Bindings in hs-boot files are not allowed") 2 (ppr mbinds) -nonStdGuardErr :: Outputable body => [LStmtLR Name Name body] -> SDoc+nonStdGuardErr :: Outputable body => [LStmtLR GhcRn GhcRn body] -> SDoc nonStdGuardErr guards = hang (text "accepting non-standard pattern guards (use PatternGuards to suppress this message)") 4 (interpp'SP guards) -unusedPatBindWarn :: HsBind Name -> SDoc+unusedPatBindWarn :: HsBind GhcRn -> SDoc unusedPatBindWarn bind = hang (text "This pattern-binding binds no variables:") 2 (ppr bind) -dupMinimalSigErr :: [LSig RdrName] -> RnM ()+dupMinimalSigErr :: [LSig GhcPs] -> RnM () dupMinimalSigErr sigs@(L loc _ : _) = addErrAt loc $ vcat [ text "Multiple minimal complete definitions"
rename/RnEnv.hs view
@@ -1,2350 +1,1588 @@ {- (c) The GRASP/AQUA Project, Glasgow University, 1992-2006 -\section[RnEnv]{Environment manipulation for the renamer monad}--}--{-# LANGUAGE CPP, MultiWayIf #-}--module RnEnv (- newTopSrcBinder,- lookupLocatedTopBndrRn, lookupTopBndrRn,- lookupLocatedOccRn, lookupOccRn, lookupOccRn_maybe,- lookupLocalOccRn_maybe, lookupInfoOccRn,- lookupLocalOccThLvl_maybe,- lookupTypeOccRn, lookupKindOccRn,- lookupGlobalOccRn, lookupGlobalOccRn_maybe,- lookupOccRn_overloaded, lookupGlobalOccRn_overloaded, lookupExactOcc,- reportUnboundName, unknownNameSuggestions,- addNameClashErrRn,-- HsSigCtxt(..), lookupLocalTcNames, lookupSigOccRn,- lookupSigCtxtOccRn,-- lookupFixityRn, lookupFixityRn_help,- lookupFieldFixityRn, lookupTyFixityRn,- lookupInstDeclBndr, lookupRecFieldOcc, lookupFamInstName,- lookupConstructorFields,- lookupSyntaxName, lookupSyntaxName', lookupSyntaxNames,- lookupIfThenElse,- lookupGreAvailRn,- getLookupOccRn,mkUnboundName, mkUnboundNameRdr, isUnboundName,- addUsedGRE, addUsedGREs, addUsedDataCons,-- newLocalBndrRn, newLocalBndrsRn,- bindLocalNames, bindLocalNamesFV,- MiniFixityEnv,- addLocalFixities,- bindLocatedLocalsFV, bindLocatedLocalsRn,- extendTyVarEnvFVRn,-- -- Role annotations- RoleAnnotEnv, emptyRoleAnnotEnv, mkRoleAnnotEnv,- lookupRoleAnnot, getRoleAnnots,-- checkDupRdrNames, checkShadowedRdrNames,- checkDupNames, checkDupAndShadowedNames, dupNamesErr,- checkTupSize,- addFvRn, mapFvRn, mapMaybeFvRn, mapFvRnCPS,- warnUnusedMatches, warnUnusedTypePatterns,- warnUnusedTopBinds, warnUnusedLocalBinds,- mkFieldEnv,- dataTcOccs, kindSigErr, perhapsForallMsg, unknownSubordinateErr,- HsDocContext(..), pprHsDocContext,- inHsDocContext, withHsDocContext- ) where--#include "HsVersions.h"--import LoadIface ( loadInterfaceForName, loadSrcInterface_maybe )-import IfaceEnv-import HsSyn-import RdrName-import HscTypes-import TcEnv-import TcRnMonad-import RdrHsSyn ( setRdrNameSpace )-import TysWiredIn ( starKindTyConName, unicodeStarKindTyConName )-import Name-import NameSet-import NameEnv-import Avail-import Module-import ConLike-import DataCon-import TyCon-import PrelNames ( mkUnboundName, isUnboundName, rOOT_MAIN, forall_tv_RDR )-import ErrUtils ( MsgDoc )-import BasicTypes ( Fixity(..), FixityDirection(..), minPrecedence,- defaultFixity, pprWarningTxtForMsg, SourceText(..) )-import SrcLoc-import Outputable-import Util-import Maybes-import BasicTypes ( TopLevelFlag(..) )-import ListSetOps ( removeDups )-import DynFlags-import FastString-import Control.Monad-import Data.List-import Data.Function ( on )-import ListSetOps ( minusList )-import Constants ( mAX_TUPLE_SIZE )-import qualified GHC.LanguageExtensions as LangExt-import Data.Maybe (isJust)--{--*********************************************************-* *- Source-code binders-* *-*********************************************************--Note [Signature lazy interface loading]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--GHC's lazy interface loading can be a bit confusing, so this Note is an-empirical description of what happens in one interesting case. When-compiling a signature module against an its implementation, we do NOT-load interface files associated with its names until after the type-checking phase. For example:-- module ASig where- data T- f :: T -> T--Suppose we compile this with -sig-of "A is ASig":-- module B where- data T = T- f T = T-- module A(module B) where- import B--During type checking, we'll load A.hi because we need to know what the-RdrEnv for the module is, but we DO NOT load the interface for B.hi!-It's wholly unnecessary: our local definition 'data T' in ASig is all-the information we need to finish type checking. This is contrast to-type checking of ordinary Haskell files, in which we would not have the-local definition "data T" and would need to consult B.hi immediately.-(Also, this situation never occurs for hs-boot files, since you're not-allowed to reexport from another module.)--After type checking, we then check that the types we provided are-consistent with the backing implementation (in checkHiBootOrHsigIface).-At this point, B.hi is loaded, because we need something to compare-against.--I discovered this behavior when trying to figure out why type class-instances for Data.Map weren't in the EPS when I was type checking a-test very much like ASig (sigof02dm): the associated interface hadn't-been loaded yet! (The larger issue is a moot point, since an instance-declared in a signature can never be a duplicate.)--This behavior might change in the future. Consider this-alternate module B:-- module B where- {-# DEPRECATED T, f "Don't use" #-}- data T = T- f T = T--One might conceivably want to report deprecation warnings when compiling-ASig with -sig-of B, in which case we need to look at B.hi to find the-deprecation warnings during renaming. At the moment, you don't get any-warning until you use the identifier further downstream. This would-require adjusting addUsedGRE so that during signature compilation,-we do not report deprecation warnings for LocalDef. See also-Note [Handling of deprecations]--}--newTopSrcBinder :: Located RdrName -> RnM Name-newTopSrcBinder (L loc rdr_name)- | Just name <- isExact_maybe rdr_name- = -- This is here to catch- -- (a) Exact-name binders created by Template Haskell- -- (b) The PrelBase defn of (say) [] and similar, for which- -- the parser reads the special syntax and returns an Exact RdrName- -- We are at a binding site for the name, so check first that it- -- the current module is the correct one; otherwise GHC can get- -- very confused indeed. This test rejects code like- -- data T = (,) Int Int- -- unless we are in GHC.Tup- if isExternalName name then- do { this_mod <- getModule- ; unless (this_mod == nameModule name)- (addErrAt loc (badOrigBinding rdr_name))- ; return name }- else -- See Note [Binders in Template Haskell] in Convert.hs- do { this_mod <- getModule- ; externaliseName this_mod name }-- | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name- = do { this_mod <- getModule- ; unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)- (addErrAt loc (badOrigBinding rdr_name))- -- When reading External Core we get Orig names as binders,- -- but they should agree with the module gotten from the monad- --- -- We can get built-in syntax showing up here too, sadly. If you type- -- data T = (,,,)- -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon- -- uses setRdrNameSpace to make it into a data constructors. At that point- -- the nice Exact name for the TyCon gets swizzled to an Orig name.- -- Hence the badOrigBinding error message.- --- -- Except for the ":Main.main = ..." definition inserted into- -- the Main module; ugh!-- -- Because of this latter case, we call newGlobalBinder with a module from- -- the RdrName, not from the environment. In principle, it'd be fine to- -- have an arbitrary mixture of external core definitions in a single module,- -- (apart from module-initialisation issues, perhaps).- ; newGlobalBinder rdr_mod rdr_occ loc }-- | otherwise- = do { unless (not (isQual rdr_name))- (addErrAt loc (badQualBndrErr rdr_name))- -- Binders should not be qualified; if they are, and with a different- -- module name, we we get a confusing "M.T is not in scope" error later-- ; stage <- getStage- ; if isBrackStage stage then- -- We are inside a TH bracket, so make an *Internal* name- -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames- do { uniq <- newUnique- ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }- else- do { this_mod <- getModule- ; traceRn "newTopSrcBinder" (ppr this_mod $$ ppr rdr_name $$ ppr loc)- ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }- }--{--*********************************************************-* *- Source code occurrences-* *-*********************************************************--Looking up a name in the RnEnv.--Note [Type and class operator definitions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We want to reject all of these unless we have -XTypeOperators (Trac #3265)- data a :*: b = ...- class a :*: b where ...- data (:*:) a b = ....- class (:*:) a b where ...-The latter two mean that we are not just looking for a-*syntactically-infix* declaration, but one that uses an operator-OccName. We use OccName.isSymOcc to detect that case, which isn't-terribly efficient, but there seems to be no better way.--}--lookupTopBndrRn :: RdrName -> RnM Name-lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n- case nopt of- Just n' -> return n'- Nothing -> do traceRn "lookupTopBndrRn fail" (ppr n)- unboundName WL_LocalTop n--lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)-lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn--lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)--- Look up a top-level source-code binder. We may be looking up an unqualified 'f',--- and there may be several imported 'f's too, which must not confuse us.--- For example, this is OK:--- import Foo( f )--- infix 9 f -- The 'f' here does not need to be qualified--- f x = x -- Nor here, of course--- So we have to filter out the non-local ones.------ A separate function (importsFromLocalDecls) reports duplicate top level--- decls, so here it's safe just to choose an arbitrary one.------ There should never be a qualified name in a binding position in Haskell,--- but there can be if we have read in an external-Core file.--- The Haskell parser checks for the illegal qualified name in Haskell--- source files, so we don't need to do so here.--lookupTopBndrRn_maybe rdr_name- | Just name <- isExact_maybe rdr_name- = do { name' <- lookupExactOcc name; return (Just name') }-- | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name- -- This deals with the case of derived bindings, where- -- we don't bother to call newTopSrcBinder first- -- We assume there is no "parent" name- = do { loc <- getSrcSpanM- ; n <- newGlobalBinder rdr_mod rdr_occ loc- ; return (Just n)}-- | otherwise- = do { -- Check for operators in type or class declarations- -- See Note [Type and class operator definitions]- let occ = rdrNameOcc rdr_name- ; when (isTcOcc occ && isSymOcc occ)- (do { op_ok <- xoptM LangExt.TypeOperators- ; unless op_ok (addErr (opDeclErr rdr_name)) })-- ; env <- getGlobalRdrEnv- ; case filter isLocalGRE (lookupGRE_RdrName rdr_name env) of- [gre] -> return (Just (gre_name gre))- _ -> return Nothing -- Ambiguous (can't happen) or unbound- }---------------------------------------------------- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].--- This adds an error if the name cannot be found.-lookupExactOcc :: Name -> RnM Name-lookupExactOcc name- = do { result <- lookupExactOcc_either name- ; case result of- Left err -> do { addErr err- ; return name }- Right name' -> return name' }---- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].--- This never adds an error, but it may return one.-lookupExactOcc_either :: Name -> RnM (Either MsgDoc Name)--- See Note [Looking up Exact RdrNames]-lookupExactOcc_either name- | Just thing <- wiredInNameTyThing_maybe name- , Just tycon <- case thing of- ATyCon tc -> Just tc- AConLike (RealDataCon dc) -> Just (dataConTyCon dc)- _ -> Nothing- , isTupleTyCon tycon- = do { checkTupSize (tyConArity tycon)- ; return (Right name) }-- | isExternalName name- = return (Right name)-- | otherwise- = do { env <- getGlobalRdrEnv- ; let -- See Note [Splicing Exact names]- main_occ = nameOccName name- demoted_occs = case demoteOccName main_occ of- Just occ -> [occ]- Nothing -> []- gres = [ gre | occ <- main_occ : demoted_occs- , gre <- lookupGlobalRdrEnv env occ- , gre_name gre == name ]- ; case gres of- [gre] -> return (Right (gre_name gre))-- [] -> -- See Note [Splicing Exact names]- do { lcl_env <- getLocalRdrEnv- ; if name `inLocalRdrEnvScope` lcl_env- then return (Right name)- else- do { th_topnames_var <- fmap tcg_th_topnames getGblEnv- ; th_topnames <- readTcRef th_topnames_var- ; if name `elemNameSet` th_topnames- then return (Right name)- else return (Left exact_nm_err)- }- }- gres -> return (Left (sameNameErr gres)) -- Ugh! See Note [Template Haskell ambiguity]- }- where- exact_nm_err = hang (text "The exact Name" <+> quotes (ppr name) <+> ptext (sLit "is not in scope"))- 2 (vcat [ text "Probable cause: you used a unique Template Haskell name (NameU), "- , text "perhaps via newName, but did not bind it"- , text "If that's it, then -ddump-splices might be useful" ])--sameNameErr :: [GlobalRdrElt] -> MsgDoc-sameNameErr [] = panic "addSameNameErr: empty list"-sameNameErr gres@(_ : _)- = hang (text "Same exact name in multiple name-spaces:")- 2 (vcat (map pp_one sorted_names) $$ th_hint)- where- sorted_names = sortWith nameSrcLoc (map gre_name gres)- pp_one name- = hang (pprNameSpace (occNameSpace (getOccName name))- <+> quotes (ppr name) <> comma)- 2 (text "declared at:" <+> ppr (nameSrcLoc name))-- th_hint = vcat [ text "Probable cause: you bound a unique Template Haskell name (NameU),"- , text "perhaps via newName, in different name-spaces."- , text "If that's it, then -ddump-splices might be useful" ]---------------------------------------------------lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name--- This is called on the method name on the left-hand side of an--- instance declaration binding. eg. instance Functor T where--- fmap = ...--- ^^^^ called on this--- Regardless of how many unqualified fmaps are in scope, we want--- the one that comes from the Functor class.------ Furthermore, note that we take no account of whether the--- name is only in scope qualified. I.e. even if method op is--- in scope as M.op, we still allow plain 'op' on the LHS of--- an instance decl------ The "what" parameter says "method" or "associated type",--- depending on what we are looking up-lookupInstDeclBndr cls what rdr- = do { when (isQual rdr)- (addErr (badQualBndrErr rdr))- -- In an instance decl you aren't allowed- -- to use a qualified name for the method- -- (Although it'd make perfect sense.)- ; mb_name <- lookupSubBndrOcc- False -- False => we don't give deprecated- -- warnings when a deprecated class- -- method is defined. We only warn- -- when it's used- cls doc rdr- ; case mb_name of- Left err -> do { addErr err; return (mkUnboundNameRdr rdr) }- Right nm -> return nm }- where- doc = what <+> text "of class" <+> quotes (ppr cls)---------------------------------------------------lookupFamInstName :: Maybe Name -> Located RdrName -> RnM (Located Name)--- Used for TyData and TySynonym family instances only,--- See Note [Family instance binders]-lookupFamInstName (Just cls) tc_rdr -- Associated type; c.f RnBinds.rnMethodBind- = wrapLocM (lookupInstDeclBndr cls (text "associated type")) tc_rdr-lookupFamInstName Nothing tc_rdr -- Family instance; tc_rdr is an *occurrence*- = lookupLocatedOccRn tc_rdr--------------------------------------------------lookupConstructorFields :: Name -> RnM [FieldLabel]--- Look up the fields of a given constructor--- * For constructors from this module, use the record field env,--- which is itself gathered from the (as yet un-typechecked)--- data type decls------ * For constructors from imported modules, use the *type* environment--- since imported modles are already compiled, the info is conveniently--- right there--lookupConstructorFields con_name- = do { this_mod <- getModule- ; if nameIsLocalOrFrom this_mod con_name then- do { field_env <- getRecFieldEnv- ; traceTc "lookupCF" (ppr con_name $$ ppr (lookupNameEnv field_env con_name) $$ ppr field_env)- ; return (lookupNameEnv field_env con_name `orElse` []) }- else- do { con <- tcLookupConLike con_name- ; traceTc "lookupCF 2" (ppr con)- ; return (conLikeFieldLabels con) } }---------------------------------------------------- Used for record construction and pattern matching--- When the -XDisambiguateRecordFields flag is on, take account of the--- constructor name to disambiguate which field to use; it's just the--- same as for instance decls------ NB: Consider this:--- module Foo where { data R = R { fld :: Int } }--- module Odd where { import Foo; fld x = x { fld = 3 } }--- Arguably this should work, because the reference to 'fld' is--- unambiguous because there is only one field id 'fld' in scope.--- But currently it's rejected.--lookupRecFieldOcc :: Maybe Name -- Nothing => just look it up as usual- -- Just tycon => use tycon to disambiguate- -> SDoc -> RdrName- -> RnM Name-lookupRecFieldOcc parent doc rdr_name- | Just tc_name <- parent- = do { mb_name <- lookupSubBndrOcc True tc_name doc rdr_name- ; case mb_name of- Left err -> do { addErr err; return (mkUnboundNameRdr rdr_name) }- Right n -> return n }-- | otherwise- = lookupGlobalOccRn rdr_name--lookupSubBndrOcc :: Bool- -> Name -- Parent- -> SDoc- -> RdrName- -> RnM (Either MsgDoc Name)--- Find all the things the rdr-name maps to--- and pick the one with the right parent namep-lookupSubBndrOcc warn_if_deprec the_parent doc rdr_name- | Just n <- isExact_maybe rdr_name -- This happens in derived code- = do { n <- lookupExactOcc n- ; return (Right n) }-- | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name- = do { n <- lookupOrig rdr_mod rdr_occ- ; return (Right n) }-- | isUnboundName the_parent- -- Avoid an error cascade from malformed decls:- -- instance Int where { foo = e }- -- We have already generated an error in rnLHsInstDecl- = return (Right (mkUnboundNameRdr rdr_name))-- | otherwise- = do { env <- getGlobalRdrEnv- ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)- -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!- -- The latter does pickGREs, but we want to allow 'x'- -- even if only 'M.x' is in scope- ; traceRn "lookupSubBndrOcc"- (vcat [ ppr the_parent, ppr rdr_name- , ppr gres, ppr (pick_gres rdr_name gres)])- ; case pick_gres rdr_name gres of- (gre:_) -> do { addUsedGRE warn_if_deprec gre- -- Add a usage; this is an *occurrence* site- -- Note [Usage for sub-bndrs]- ; return (Right (gre_name gre)) }- -- If there is more than one local GRE for the- -- same OccName 'f', that will be reported separately- -- as a duplicate top-level binding for 'f'- [] -> do { ns <- lookupQualifiedNameGHCi rdr_name- ; case ns of- (n:_) -> return (Right n) -- Unlikely to be more than one...?- [] -> return (Left (unknownSubordinateErr doc rdr_name))- } }- where- -- If Parent = NoParent, just do a normal lookup- -- If Parent = Parent p then find all GREs that- -- (a) have parent p- -- (b) for Unqual, are in scope qualified or unqualified- -- for Qual, are in scope with that qualification- pick_gres rdr_name gres- | isUnqual rdr_name = filter right_parent gres- | otherwise = filter right_parent (pickGREs rdr_name gres)-- right_parent (GRE { gre_par = p })- | ParentIs parent <- p = parent == the_parent- | FldParent { par_is = parent } <- p = parent == the_parent- | otherwise = False--{--Note [Family instance binders]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider- data family F a- data instance F T = X1 | X2--The 'data instance' decl has an *occurrence* of F (and T), and *binds*-X1 and X2. (This is unlike a normal data type declaration which would-bind F too.) So we want an AvailTC F [X1,X2].--Now consider a similar pair:- class C a where- data G a- instance C S where- data G S = Y1 | Y2--The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.--But there is a small complication: in an instance decl, we don't use-qualified names on the LHS; instead we use the class to disambiguate.-Thus:- module M where- import Blib( G )- class C a where- data G a- instance C S where- data G S = Y1 | Y2-Even though there are two G's in scope (M.G and Blib.G), the occurrence-of 'G' in the 'instance C S' decl is unambiguous, because C has only-one associated type called G. This is exactly what happens for methods,-and it is only consistent to do the same thing for types. That's the-role of the function lookupTcdName; the (Maybe Name) give the class of-the encloseing instance decl, if any.--Note [Looking up Exact RdrNames]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Exact RdrNames are generated by Template Haskell. See Note [Binders-in Template Haskell] in Convert.--For data types and classes have Exact system Names in the binding-positions for constructors, TyCons etc. For example- [d| data T = MkT Int |]-when we splice in and Convert to HsSyn RdrName, we'll get- data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...-These System names are generated by Convert.thRdrName--But, constructors and the like need External Names, not System Names!-So we do the following-- * In RnEnv.newTopSrcBinder we spot Exact RdrNames that wrap a- non-External Name, and make an External name for it. This is- the name that goes in the GlobalRdrEnv-- * When looking up an occurrence of an Exact name, done in- RnEnv.lookupExactOcc, we find the Name with the right unique in the- GlobalRdrEnv, and use the one from the envt -- it will be an- External Name in the case of the data type/constructor above.-- * Exact names are also use for purely local binders generated- by TH, such as \x_33. x_33- Both binder and occurrence are Exact RdrNames. The occurrence- gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and- misses, because lookupLocalRdrEnv always returns Nothing for- an Exact Name. Now we fall through to lookupExactOcc, which- will find the Name is not in the GlobalRdrEnv, so we just use- the Exact supplied Name.--Note [Splicing Exact names]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider the splice $(do { x <- newName "x"; return (VarE x) })-This will generate a (HsExpr RdrName) term that mentions the-Exact RdrName "x_56" (or whatever), but does not bind it. So-when looking such Exact names we want to check that it's in scope,-otherwise the type checker will get confused. To do this we need to-keep track of all the Names in scope, and the LocalRdrEnv does just that;-we consult it with RdrName.inLocalRdrEnvScope.--There is another wrinkle. With TH and -XDataKinds, consider- $( [d| data Nat = Zero- data T = MkT (Proxy 'Zero) |] )-After splicing, but before renaming we get this:- data Nat_77{tc} = Zero_78{d}- data T_79{tc} = MkT_80{d} (Proxy 'Zero_78{tc}) |] )-The occurrence of 'Zero in the data type for T has the right unique,-but it has a TcClsName name-space in its OccName. (This is set by-the ctxt_ns argument of Convert.thRdrName.) When we check that is-in scope in the GlobalRdrEnv, we need to look up the DataName namespace-too. (An alternative would be to make the GlobalRdrEnv also have-a Name -> GRE mapping.)--Note [Template Haskell ambiguity]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The GlobalRdrEnv invariant says that if- occ -> [gre1, ..., gren]-then the gres have distinct Names (INVARIANT 1 of GlobalRdrEnv).-This is guaranteed by extendGlobalRdrEnvRn (the dups check in add_gre).--So how can we get multiple gres in lookupExactOcc_maybe? Because in-TH we might use the same TH NameU in two different name spaces.-eg (Trac #7241):- $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])-Here we generate a type constructor and data constructor with the same-unique, but differnt name spaces.--It'd be nicer to rule this out in extendGlobalRdrEnvRn, but that would-mean looking up the OccName in every name-space, just in case, and that-seems a bit brutal. So it's just done here on lookup. But we might-need to revisit that choice.--Note [Usage for sub-bndrs]-~~~~~~~~~~~~~~~~~~~~~~~~~~-If you have this- import qualified M( C( f ) )- instance M.C T where- f x = x-then is the qualified import M.f used? Obviously yes.-But the RdrName used in the instance decl is unqualified. In effect,-we fill in the qualification by looking for f's whose class is M.C-But when adding to the UsedRdrNames we must make that qualification-explicit (saying "used M.f"), otherwise we get "Redundant import of M.f".--So we make up a suitable (fake) RdrName. But be careful- import qualified M- import M( C(f) )- instance C T where- f x = x-Here we want to record a use of 'f', not of 'M.f', otherwise-we'll miss the fact that the qualified import is redundant.------------------------------------------------------- Occurrences-----------------------------------------------------}--getLookupOccRn :: RnM (Name -> Maybe Name)-getLookupOccRn- = do local_env <- getLocalRdrEnv- return (lookupLocalRdrOcc local_env . nameOccName)--mkUnboundNameRdr :: RdrName -> Name-mkUnboundNameRdr rdr = mkUnboundName (rdrNameOcc rdr)--lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)-lookupLocatedOccRn = wrapLocM lookupOccRn--lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)--- Just look in the local environment-lookupLocalOccRn_maybe rdr_name- = do { local_env <- getLocalRdrEnv- ; return (lookupLocalRdrEnv local_env rdr_name) }--lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))--- Just look in the local environment-lookupLocalOccThLvl_maybe name- = do { lcl_env <- getLclEnv- ; return (lookupNameEnv (tcl_th_bndrs lcl_env) name) }---- lookupOccRn looks up an occurrence of a RdrName-lookupOccRn :: RdrName -> RnM Name-lookupOccRn rdr_name- = do { mb_name <- lookupOccRn_maybe rdr_name- ; case mb_name of- Just name -> return name- Nothing -> reportUnboundName rdr_name }--lookupKindOccRn :: RdrName -> RnM Name--- Looking up a name occurring in a kind-lookupKindOccRn rdr_name- | isVarOcc (rdrNameOcc rdr_name) -- See Note [Promoted variables in types]- = badVarInType rdr_name- | otherwise- = do { typeintype <- xoptM LangExt.TypeInType- ; if | typeintype -> lookupTypeOccRn rdr_name- -- With -XNoTypeInType, treat any usage of * in kinds as in scope- -- this is a dirty hack, but then again so was the old * kind.- | is_star rdr_name -> return starKindTyConName- | is_uni_star rdr_name -> return unicodeStarKindTyConName- | otherwise -> lookupOccRn rdr_name }---- lookupPromotedOccRn looks up an optionally promoted RdrName.-lookupTypeOccRn :: RdrName -> RnM Name--- see Note [Demotion]-lookupTypeOccRn rdr_name- | isVarOcc (rdrNameOcc rdr_name) -- See Note [Promoted variables in types]- = badVarInType rdr_name- | otherwise- = do { mb_name <- lookupOccRn_maybe rdr_name- ; case mb_name of {- Just name -> return name ;- Nothing -> do { dflags <- getDynFlags- ; lookup_demoted rdr_name dflags } } }--lookup_demoted :: RdrName -> DynFlags -> RnM Name-lookup_demoted rdr_name dflags- | Just demoted_rdr <- demoteRdrName rdr_name- -- Maybe it's the name of a *data* constructor- = do { data_kinds <- xoptM LangExt.DataKinds- ; if data_kinds- then do { mb_demoted_name <- lookupOccRn_maybe demoted_rdr- ; case mb_demoted_name of- Nothing -> unboundNameX WL_Any rdr_name star_info- Just demoted_name ->- do { whenWOptM Opt_WarnUntickedPromotedConstructors $- addWarn- (Reason Opt_WarnUntickedPromotedConstructors)- (untickedPromConstrWarn demoted_name)- ; return demoted_name } }- else do { -- We need to check if a data constructor of this name is- -- in scope to give good error messages. However, we do- -- not want to give an additional error if the data- -- constructor happens to be out of scope! See #13947.- mb_demoted_name <- discardErrs $- lookupOccRn_maybe demoted_rdr- ; let suggestion | isJust mb_demoted_name = suggest_dk- | otherwise = star_info- ; unboundNameX WL_Any rdr_name suggestion } }-- | otherwise- = reportUnboundName rdr_name-- where- suggest_dk = text "A data constructor of that name is in scope; did you mean DataKinds?"- untickedPromConstrWarn name =- text "Unticked promoted constructor" <> colon <+> quotes (ppr name) <> dot- $$- hsep [ text "Use"- , quotes (char '\'' <> ppr name)- , text "instead of"- , quotes (ppr name) <> dot ]-- star_info- | is_star rdr_name || is_uni_star rdr_name- = if xopt LangExt.TypeInType dflags- then text "NB: With TypeInType, you must import" <+>- ppr rdr_name <+> text "from Data.Kind"- else empty-- | otherwise- = empty--is_star, is_uni_star :: RdrName -> Bool-is_star = (fsLit "*" ==) . occNameFS . rdrNameOcc-is_uni_star = (fsLit "★" ==) . occNameFS . rdrNameOcc--badVarInType :: RdrName -> RnM Name-badVarInType rdr_name- = do { addErr (text "Illegal promoted term variable in a type:"- <+> ppr rdr_name)- ; return (mkUnboundNameRdr rdr_name) }--{- Note [Promoted variables in types]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider this (Trac #12686):- x = True- data Bad = Bad 'x--The parser treats the quote in 'x as saying "use the term-namespace", so we'll get (Bad x{v}), with 'x' in the-VarName namespace. If we don't test for this, the renamer-will happily rename it to the x bound at top level, and then-the typecheck falls over because it doesn't have 'x' in scope-when kind-checking.--Note [Demotion]-~~~~~~~~~~~~~~~-When the user writes:- data Nat = Zero | Succ Nat- foo :: f Zero -> Int--'Zero' in the type signature of 'foo' is parsed as:- HsTyVar ("Zero", TcClsName)--When the renamer hits this occurrence of 'Zero' it's going to realise-that it's not in scope. But because it is renaming a type, it knows-that 'Zero' might be a promoted data constructor, so it will demote-its namespace to DataName and do a second lookup.--The final result (after the renamer) will be:- HsTyVar ("Zero", DataName)--}---- Use this version to get tracing------ lookupOccRn_maybe, lookupOccRn_maybe' :: RdrName -> RnM (Maybe Name)--- lookupOccRn_maybe rdr_name--- = do { mb_res <- lookupOccRn_maybe' rdr_name--- ; gbl_rdr_env <- getGlobalRdrEnv--- ; local_rdr_env <- getLocalRdrEnv--- ; traceRn $ text "lookupOccRn_maybe" <+>--- vcat [ ppr rdr_name <+> ppr (getUnique (rdrNameOcc rdr_name))--- , ppr mb_res--- , text "Lcl env" <+> ppr local_rdr_env--- , text "Gbl env" <+> ppr [ (getUnique (nameOccName (gre_name (head gres'))),gres') | gres <- occEnvElts gbl_rdr_env--- , let gres' = filter isLocalGRE gres, not (null gres') ] ]--- ; return mb_res }--lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)--- lookupOccRn looks up an occurrence of a RdrName-lookupOccRn_maybe rdr_name- = do { local_env <- getLocalRdrEnv- ; case lookupLocalRdrEnv local_env rdr_name of {- Just name -> return (Just name) ;- Nothing -> do- ; lookupGlobalOccRn_maybe rdr_name } }--lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)--- Looks up a RdrName occurrence in the top-level--- environment, including using lookupQualifiedNameGHCi--- for the GHCi case--- No filter function; does not report an error on failure--- Uses addUsedRdrName to record use and deprecations-lookupGlobalOccRn_maybe rdr_name- | Just n <- isExact_maybe rdr_name -- This happens in derived code- = do { n' <- lookupExactOcc n; return (Just n') }-- | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name- = do { n <- lookupOrig rdr_mod rdr_occ- ; return (Just n) }-- | otherwise- = do { mb_gre <- lookupGreRn_maybe rdr_name- ; case mb_gre of {- Just gre -> return (Just (gre_name gre)) ;- Nothing ->- do { ns <- lookupQualifiedNameGHCi rdr_name- -- This test is not expensive,- -- and only happens for failed lookups- ; case ns of- (n:_) -> return (Just n) -- Unlikely to be more than one...?- [] -> return Nothing } } }--lookupGlobalOccRn :: RdrName -> RnM Name--- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global--- environment. Adds an error message if the RdrName is not in scope.-lookupGlobalOccRn rdr_name- = do { mb_name <- lookupGlobalOccRn_maybe rdr_name- ; case mb_name of- Just n -> return n- Nothing -> do { traceRn "lookupGlobalOccRn" (ppr rdr_name)- ; unboundName WL_Global rdr_name } }--lookupInfoOccRn :: RdrName -> RnM [Name]--- lookupInfoOccRn is intended for use in GHCi's ":info" command--- It finds all the GREs that RdrName could mean, not complaining--- about ambiguity, but rather returning them all--- C.f. Trac #9881-lookupInfoOccRn rdr_name- | Just n <- isExact_maybe rdr_name -- e.g. (->)- = return [n]-- | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name- = do { n <- lookupOrig rdr_mod rdr_occ- ; return [n] }-- | otherwise- = do { rdr_env <- getGlobalRdrEnv- ; let ns = map gre_name (lookupGRE_RdrName rdr_name rdr_env)- ; qual_ns <- lookupQualifiedNameGHCi rdr_name- ; return (ns ++ (qual_ns `minusList` ns)) }---- | Like 'lookupOccRn_maybe', but with a more informative result if--- the 'RdrName' happens to be a record selector:------ * Nothing -> name not in scope (no error reported)--- * Just (Left x) -> name uniquely refers to x,--- or there is a name clash (reported)--- * Just (Right xs) -> name refers to one or more record selectors;--- if overload_ok was False, this list will be--- a singleton.-lookupOccRn_overloaded :: Bool -> RdrName -> RnM (Maybe (Either Name [FieldOcc Name]))-lookupOccRn_overloaded overload_ok rdr_name- = do { local_env <- getLocalRdrEnv- ; case lookupLocalRdrEnv local_env rdr_name of {- Just name -> return (Just (Left name)) ;- Nothing -> do- { mb_name <- lookupGlobalOccRn_overloaded overload_ok rdr_name- ; case mb_name of {- Just name -> return (Just name) ;- Nothing -> do- { ns <- lookupQualifiedNameGHCi rdr_name- -- This test is not expensive,- -- and only happens for failed lookups- ; case ns of- (n:_) -> return $ Just $ Left n -- Unlikely to be more than one...?- [] -> return Nothing } } } } }--lookupGlobalOccRn_overloaded :: Bool -> RdrName -> RnM (Maybe (Either Name [FieldOcc Name]))-lookupGlobalOccRn_overloaded overload_ok rdr_name- | Just n <- isExact_maybe rdr_name -- This happens in derived code- = do { n' <- lookupExactOcc n; return (Just (Left n')) }-- | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name- = do { n <- lookupOrig rdr_mod rdr_occ- ; return (Just (Left n)) }-- | otherwise- = do { env <- getGlobalRdrEnv- ; case lookupGRE_RdrName rdr_name env of- [] -> return Nothing- [gre] | isRecFldGRE gre- -> do { addUsedGRE True gre- ; let- fld_occ :: FieldOcc Name- fld_occ- = FieldOcc (noLoc rdr_name) (gre_name gre)- ; return (Just (Right [fld_occ])) }- | otherwise- -> do { addUsedGRE True gre- ; return (Just (Left (gre_name gre))) }- gres | all isRecFldGRE gres && overload_ok- -- Don't record usage for ambiguous selectors- -- until we know which is meant- -> return- (Just (Right- (map (FieldOcc (noLoc rdr_name) . gre_name)- gres)))- gres -> do { addNameClashErrRn rdr_name gres- ; return (Just (Left (gre_name (head gres)))) } }-------------------------------------------------------- Lookup in the Global RdrEnv of the module-----------------------------------------------------lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)--- Look up the RdrName in the GlobalRdrEnv--- Exactly one binding: records it as "used", return (Just gre)--- No bindings: return Nothing--- Many bindings: report "ambiguous", return an arbitrary (Just gre)--- (This API is a bit strange; lookupGRERn2_maybe is simpler.--- But it works and I don't want to fiddle too much.)--- Uses addUsedRdrName to record use and deprecations-lookupGreRn_maybe rdr_name- = do { env <- getGlobalRdrEnv- ; case lookupGRE_RdrName rdr_name env of- [] -> return Nothing- [gre] -> do { addUsedGRE True gre- ; return (Just gre) }- gres -> do { addNameClashErrRn rdr_name gres- ; traceRn "lookupGreRn:name clash"- (ppr rdr_name $$ ppr gres $$ ppr env)- ; return (Just (head gres)) } }--lookupGreRn2_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)--- Look up the RdrName in the GlobalRdrEnv--- Exactly one binding: record it as "used", return (Just gre)--- No bindings: report "not in scope", return Nothing--- Many bindings: report "ambiguous", return Nothing--- Uses addUsedRdrName to record use and deprecations-lookupGreRn2_maybe rdr_name- = do { env <- getGlobalRdrEnv- ; case lookupGRE_RdrName rdr_name env of- [] -> do { _ <- unboundName WL_Global rdr_name- ; return Nothing }- [gre] -> do { addUsedGRE True gre- ; return (Just gre) }- gres -> do { addNameClashErrRn rdr_name gres- ; traceRn "lookupGreRn_maybe:name clash"- (ppr rdr_name $$ ppr gres $$ ppr env)- ; return Nothing } }--lookupGreAvailRn :: RdrName -> RnM (Name, AvailInfo)--- Used in export lists--- If not found or ambiguous, add error message, and fake with UnboundName--- Uses addUsedRdrName to record use and deprecations-lookupGreAvailRn rdr_name- = do { mb_gre <- lookupGreRn2_maybe rdr_name- ; case mb_gre of {- Just gre -> return (gre_name gre, availFromGRE gre) ;- Nothing ->- do { traceRn "lookupGreAvailRn" (ppr rdr_name)- ; let name = mkUnboundNameRdr rdr_name- ; return (name, avail name) } } }--{--*********************************************************-* *- Deprecations-* *-*********************************************************--Note [Handling of deprecations]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-* We report deprecations at each *occurrence* of the deprecated thing- (see Trac #5867)--* We do not report deprecations for locally-defined names. For a- start, we may be exporting a deprecated thing. Also we may use a- deprecated thing in the defn of another deprecated things. We may- even use a deprecated thing in the defn of a non-deprecated thing,- when changing a module's interface.--* addUsedGREs: we do not report deprecations for sub-binders:- - the ".." completion for records- - the ".." in an export item 'T(..)'- - the things exported by a module export 'module M'--}--addUsedDataCons :: GlobalRdrEnv -> TyCon -> RnM ()--- Remember use of in-scope data constructors (Trac #7969)-addUsedDataCons rdr_env tycon- = addUsedGREs [ gre- | dc <- tyConDataCons tycon- , Just gre <- [lookupGRE_Name rdr_env (dataConName dc)] ]--addUsedGRE :: Bool -> GlobalRdrElt -> RnM ()--- Called for both local and imported things--- Add usage *and* warn if deprecated-addUsedGRE warn_if_deprec gre- = do { when warn_if_deprec (warnIfDeprecated gre)- ; unless (isLocalGRE gre) $- do { env <- getGblEnv- ; traceRn "addUsedGRE" (ppr gre)- ; updMutVar (tcg_used_gres env) (gre :) } }--addUsedGREs :: [GlobalRdrElt] -> RnM ()--- Record uses of any *imported* GREs--- Used for recording used sub-bndrs--- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]-addUsedGREs gres- | null imp_gres = return ()- | otherwise = do { env <- getGblEnv- ; traceRn "addUsedGREs" (ppr imp_gres)- ; updMutVar (tcg_used_gres env) (imp_gres ++) }- where- imp_gres = filterOut isLocalGRE gres--warnIfDeprecated :: GlobalRdrElt -> RnM ()-warnIfDeprecated gre@(GRE { gre_name = name, gre_imp = iss })- | (imp_spec : _) <- iss- = do { dflags <- getDynFlags- ; this_mod <- getModule- ; when (wopt Opt_WarnWarningsDeprecations dflags &&- not (nameIsLocalOrFrom this_mod name)) $- -- See Note [Handling of deprecations]- do { iface <- loadInterfaceForName doc name- ; case lookupImpDeprec iface gre of- Just txt -> addWarn (Reason Opt_WarnWarningsDeprecations)- (mk_msg imp_spec txt)- Nothing -> return () } }- | otherwise- = return ()- where- occ = greOccName gre- name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name- doc = text "The name" <+> quotes (ppr occ) <+> ptext (sLit "is mentioned explicitly")-- mk_msg imp_spec txt- = sep [ sep [ text "In the use of"- <+> pprNonVarNameSpace (occNameSpace occ)- <+> quotes (ppr occ)- , parens imp_msg <> colon ]- , pprWarningTxtForMsg txt ]- where- imp_mod = importSpecModule imp_spec- imp_msg = text "imported from" <+> ppr imp_mod <> extra- extra | imp_mod == moduleName name_mod = Outputable.empty- | otherwise = text ", but defined in" <+> ppr name_mod--lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt-lookupImpDeprec iface gre- = mi_warn_fn iface (greOccName gre) `mplus` -- Bleat if the thing,- case gre_par gre of -- or its parent, is warn'd- ParentIs p -> mi_warn_fn iface (nameOccName p)- FldParent { par_is = p } -> mi_warn_fn iface (nameOccName p)- NoParent -> Nothing--{--Note [Used names with interface not loaded]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's (just) possible to find a used-Name whose interface hasn't been loaded:--a) It might be a WiredInName; in that case we may not load- its interface (although we could).--b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger- These are seen as "used" by the renamer (if -XRebindableSyntax)- is on), but the typechecker may discard their uses- if in fact the in-scope fromRational is GHC.Read.fromRational,- (see tcPat.tcOverloadedLit), and the typechecker sees that the type- is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).- In that obscure case it won't force the interface in.--In both cases we simply don't permit deprecations;-this is, after all, wired-in stuff.---*********************************************************-* *- GHCi support-* *-*********************************************************--A qualified name on the command line can refer to any module at-all: we try to load the interface if we don't already have it, just-as if there was an "import qualified M" declaration for every-module.--If we fail we just return Nothing, rather than bleating-about "attempting to use module ‘D’ (./D.hs) which is not loaded"-which is what loadSrcInterface does.--Note [Safe Haskell and GHCi]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We DONT do this Safe Haskell as we need to check imports. We can-and should instead check the qualified import but at the moment-this requires some refactoring so leave as a TODO--}--lookupQualifiedNameGHCi :: RdrName -> RnM [Name]-lookupQualifiedNameGHCi rdr_name- = -- We want to behave as we would for a source file import here,- -- and respect hiddenness of modules/packages, hence loadSrcInterface.- do { dflags <- getDynFlags- ; is_ghci <- getIsGHCi- ; go_for_it dflags is_ghci }-- where- go_for_it dflags is_ghci- | Just (mod,occ) <- isQual_maybe rdr_name- , is_ghci- , gopt Opt_ImplicitImportQualified dflags -- Enables this GHCi behaviour- , not (safeDirectImpsReq dflags) -- See Note [Safe Haskell and GHCi]- = do { res <- loadSrcInterface_maybe doc mod False Nothing- ; case res of- Succeeded iface- -> return [ name- | avail <- mi_exports iface- , name <- availNames avail- , nameOccName name == occ ]-- _ -> -- Either we couldn't load the interface, or- -- we could but we didn't find the name in it- do { traceRn "lookupQualifiedNameGHCi" (ppr rdr_name)- ; return [] } }-- | otherwise- = do { traceRn "lookupQualifiedNameGHCi: off" (ppr rdr_name)- ; return [] }-- doc = text "Need to find" <+> ppr rdr_name--{--Note [Looking up signature names]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-lookupSigOccRn is used for type signatures and pragmas-Is this valid?- module A- import M( f )- f :: Int -> Int- f x = x-It's clear that the 'f' in the signature must refer to A.f-The Haskell98 report does not stipulate this, but it will!-So we must treat the 'f' in the signature in the same way-as the binding occurrence of 'f', using lookupBndrRn--However, consider this case:- import M( f )- f :: Int -> Int- g x = x-We don't want to say 'f' is out of scope; instead, we want to-return the imported 'f', so that later on the reanamer will-correctly report "misplaced type sig".--Note [Signatures for top level things]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-data HsSigCtxt = ... | TopSigCtxt NameSet | ....--* The NameSet says what is bound in this group of bindings.- We can't use isLocalGRE from the GlobalRdrEnv, because of this:- f x = x- $( ...some TH splice... )- f :: Int -> Int- When we encounter the signature for 'f', the binding for 'f'- will be in the GlobalRdrEnv, and will be a LocalDef. Yet the- signature is mis-placed--* For type signatures the NameSet should be the names bound by the- value bindings; for fixity declarations, the NameSet should also- include class sigs and record selectors-- infix 3 `f` -- Yes, ok- f :: C a => a -> a -- No, not ok- class C a where- f :: a -> a--}--data HsSigCtxt- = TopSigCtxt NameSet -- At top level, binding these names- -- See Note [Signatures for top level things]- | LocalBindCtxt NameSet -- In a local binding, binding these names- | ClsDeclCtxt Name -- Class decl for this class- | InstDeclCtxt NameSet -- Instance decl whose user-written method- -- bindings are for these methods- | HsBootCtxt NameSet -- Top level of a hs-boot file, binding these names- | RoleAnnotCtxt NameSet -- A role annotation, with the names of all types- -- in the group--instance Outputable HsSigCtxt where- ppr (TopSigCtxt ns) = text "TopSigCtxt" <+> ppr ns- ppr (LocalBindCtxt ns) = text "LocalBindCtxt" <+> ppr ns- ppr (ClsDeclCtxt n) = text "ClsDeclCtxt" <+> ppr n- ppr (InstDeclCtxt ns) = text "InstDeclCtxt" <+> ppr ns- ppr (HsBootCtxt ns) = text "HsBootCtxt" <+> ppr ns- ppr (RoleAnnotCtxt ns) = text "RoleAnnotCtxt" <+> ppr ns--lookupSigOccRn :: HsSigCtxt- -> Sig RdrName- -> Located RdrName -> RnM (Located Name)-lookupSigOccRn ctxt sig = lookupSigCtxtOccRn ctxt (hsSigDoc sig)---- | Lookup a name in relation to the names in a 'HsSigCtxt'-lookupSigCtxtOccRn :: HsSigCtxt- -> SDoc -- ^ description of thing we're looking up,- -- like "type family"- -> Located RdrName -> RnM (Located Name)-lookupSigCtxtOccRn ctxt what- = wrapLocM $ \ rdr_name ->- do { mb_name <- lookupBindGroupOcc ctxt what rdr_name- ; case mb_name of- Left err -> do { addErr err; return (mkUnboundNameRdr rdr_name) }- Right name -> return name }--lookupBindGroupOcc :: HsSigCtxt- -> SDoc- -> RdrName -> RnM (Either MsgDoc Name)--- Looks up the RdrName, expecting it to resolve to one of the--- bound names passed in. If not, return an appropriate error message------ See Note [Looking up signature names]-lookupBindGroupOcc ctxt what rdr_name- | Just n <- isExact_maybe rdr_name- = lookupExactOcc_either n -- allow for the possibility of missing Exacts;- -- see Note [dataTcOccs and Exact Names]- -- Maybe we should check the side conditions- -- but it's a pain, and Exact things only show- -- up when you know what you are doing-- | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name- = do { n' <- lookupOrig rdr_mod rdr_occ- ; return (Right n') }-- | otherwise- = case ctxt of- HsBootCtxt ns -> lookup_top (`elemNameSet` ns)- TopSigCtxt ns -> lookup_top (`elemNameSet` ns)- RoleAnnotCtxt ns -> lookup_top (`elemNameSet` ns)- LocalBindCtxt ns -> lookup_group ns- ClsDeclCtxt cls -> lookup_cls_op cls- InstDeclCtxt ns -> lookup_top (`elemNameSet` ns)- where- lookup_cls_op cls- = lookupSubBndrOcc True cls doc rdr_name- where- doc = text "method of class" <+> quotes (ppr cls)-- lookup_top keep_me- = do { env <- getGlobalRdrEnv- ; let all_gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)- ; case filter (keep_me . gre_name) all_gres of- [] | null all_gres -> bale_out_with Outputable.empty- | otherwise -> bale_out_with local_msg- (gre:_) -> return (Right (gre_name gre)) }-- lookup_group bound_names -- Look in the local envt (not top level)- = do { local_env <- getLocalRdrEnv- ; case lookupLocalRdrEnv local_env rdr_name of- Just n- | n `elemNameSet` bound_names -> return (Right n)- | otherwise -> bale_out_with local_msg- Nothing -> bale_out_with Outputable.empty }-- bale_out_with msg- = return (Left (sep [ text "The" <+> what- <+> text "for" <+> quotes (ppr rdr_name)- , nest 2 $ text "lacks an accompanying binding"]- $$ nest 2 msg))-- local_msg = parens $ text "The" <+> what <+> ptext (sLit "must be given where")- <+> quotes (ppr rdr_name) <+> text "is declared"-------------------lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [(RdrName, Name)]--- GHC extension: look up both the tycon and data con or variable.--- Used for top-level fixity signatures and deprecations.--- Complain if neither is in scope.--- See Note [Fixity signature lookup]-lookupLocalTcNames ctxt what rdr_name- = do { mb_gres <- mapM lookup (dataTcOccs rdr_name)- ; let (errs, names) = splitEithers mb_gres- ; when (null names) $ addErr (head errs) -- Bleat about one only- ; return names }- where- lookup rdr = do { name <- lookupBindGroupOcc ctxt what rdr- ; return (fmap ((,) rdr) name) }--dataTcOccs :: RdrName -> [RdrName]--- Return both the given name and the same name promoted to the TcClsName--- namespace. This is useful when we aren't sure which we are looking at.--- See also Note [dataTcOccs and Exact Names]-dataTcOccs rdr_name- | isDataOcc occ || isVarOcc occ- = [rdr_name, rdr_name_tc]- | otherwise- = [rdr_name]- where- occ = rdrNameOcc rdr_name- rdr_name_tc = setRdrNameSpace rdr_name tcName--{--Note [dataTcOccs and Exact Names]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Exact RdrNames can occur in code generated by Template Haskell, and generally-those references are, well, exact. However, the TH `Name` type isn't expressive-enough to always track the correct namespace information, so we sometimes get-the right Unique but wrong namespace. Thus, we still have to do the double-lookup-for Exact RdrNames.--There is also an awkward situation for built-in syntax. Example in GHCi- :info []-This parses as the Exact RdrName for nilDataCon, but we also want-the list type constructor.--Note that setRdrNameSpace on an Exact name requires the Name to be External,-which it always is for built in syntax.--*********************************************************-* *- Fixities-* *-*********************************************************--Note [Fixity signature lookup]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A fixity declaration like-- infixr 2 ?--can refer to a value-level operator, e.g.:-- (?) :: String -> String -> String--or a type-level operator, like:-- data (?) a b = A a | B b--so we extend the lookup of the reader name '?' to the TcClsName namespace, as-well as the original namespace.--The extended lookup is also used in other places, like resolution of-deprecation declarations, and lookup of names in GHCi.--}-----------------------------------type MiniFixityEnv = FastStringEnv (Located Fixity)- -- Mini fixity env for the names we're about- -- to bind, in a single binding group- --- -- It is keyed by the *FastString*, not the *OccName*, because- -- the single fixity decl infix 3 T- -- affects both the data constructor T and the type constrctor T- --- -- We keep the location so that if we find- -- a duplicate, we can report it sensibly------------------------------------- Used for nested fixity decls to bind names along with their fixities.--- the fixities are given as a UFM from an OccName's FastString to a fixity decl--addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a-addLocalFixities mini_fix_env names thing_inside- = extendFixityEnv (mapMaybe find_fixity names) thing_inside- where- find_fixity name- = case lookupFsEnv mini_fix_env (occNameFS occ) of- Just (L _ fix) -> Just (name, FixItem occ fix)- Nothing -> Nothing- where- occ = nameOccName name--{-----------------------------------lookupFixity is a bit strange.--* Nested local fixity decls are put in the local fixity env, which we- find with getFixtyEnv--* Imported fixities are found in the PIT--* Top-level fixity decls in this module may be for Names that are- either Global (constructors, class operations)- or Local/Exported (everything else)- (See notes with RnNames.getLocalDeclBinders for why we have this split.)- We put them all in the local fixity environment--}--lookupFixityRn :: Name -> RnM Fixity-lookupFixityRn name = lookupFixityRn' name (nameOccName name)--lookupFixityRn' :: Name -> OccName -> RnM Fixity-lookupFixityRn' name = fmap snd . lookupFixityRn_help' name---- | 'lookupFixityRn_help' returns @(True, fixity)@ if it finds a 'Fixity'--- in a local environment or from an interface file. Otherwise, it returns--- @(False, fixity)@ (e.g., for unbound 'Name's or 'Name's without--- user-supplied fixity declarations).-lookupFixityRn_help :: Name- -> RnM (Bool, Fixity)-lookupFixityRn_help name =- lookupFixityRn_help' name (nameOccName name)--lookupFixityRn_help' :: Name- -> OccName- -> RnM (Bool, Fixity)-lookupFixityRn_help' name occ- | isUnboundName name- = return (False, Fixity NoSourceText minPrecedence InfixL)- -- Minimise errors from ubound names; eg- -- a>0 `foo` b>0- -- where 'foo' is not in scope, should not give an error (Trac #7937)-- | otherwise- = do { local_fix_env <- getFixityEnv- ; case lookupNameEnv local_fix_env name of {- Just (FixItem _ fix) -> return (True, fix) ;- Nothing ->-- do { this_mod <- getModule- ; if nameIsLocalOrFrom this_mod name- -- Local (and interactive) names are all in the- -- fixity env, and don't have entries in the HPT- then return (False, defaultFixity)- else lookup_imported } } }- where- lookup_imported- -- For imported names, we have to get their fixities by doing a- -- loadInterfaceForName, and consulting the Ifaces that comes back- -- from that, because the interface file for the Name might not- -- have been loaded yet. Why not? Suppose you import module A,- -- which exports a function 'f', thus;- -- module CurrentModule where- -- import A( f )- -- module A( f ) where- -- import B( f )- -- Then B isn't loaded right away (after all, it's possible that- -- nothing from B will be used). When we come across a use of- -- 'f', we need to know its fixity, and it's then, and only- -- then, that we load B.hi. That is what's happening here.- --- -- loadInterfaceForName will find B.hi even if B is a hidden module,- -- and that's what we want.- = do { iface <- loadInterfaceForName doc name- ; let mb_fix = mi_fix_fn iface occ- ; let msg = case mb_fix of- Nothing ->- text "looking up name" <+> ppr name- <+> text "in iface, but found no fixity for it."- <+> text "Using default fixity instead."- Just f ->- text "looking up name in iface and found:"- <+> vcat [ppr name, ppr f]- ; traceRn "lookupFixityRn_either:" msg- ; return (maybe (False, defaultFixity) (\f -> (True, f)) mb_fix) }-- doc = text "Checking fixity for" <+> ppr name------------------lookupTyFixityRn :: Located Name -> RnM Fixity-lookupTyFixityRn (L _ n) = lookupFixityRn n---- | Look up the fixity of a (possibly ambiguous) occurrence of a record field--- selector. We use 'lookupFixityRn'' so that we can specifiy the 'OccName' as--- the field label, which might be different to the 'OccName' of the selector--- 'Name' if @DuplicateRecordFields@ is in use (Trac #1173). If there are--- multiple possible selectors with different fixities, generate an error.-lookupFieldFixityRn :: AmbiguousFieldOcc Name -> RnM Fixity-lookupFieldFixityRn (Unambiguous (L _ rdr) n)- = lookupFixityRn' n (rdrNameOcc rdr)-lookupFieldFixityRn (Ambiguous (L _ rdr) _) = get_ambiguous_fixity rdr- where- get_ambiguous_fixity :: RdrName -> RnM Fixity- get_ambiguous_fixity rdr_name = do- traceRn "get_ambiguous_fixity" (ppr rdr_name)- rdr_env <- getGlobalRdrEnv- let elts = lookupGRE_RdrName rdr_name rdr_env-- fixities <- groupBy ((==) `on` snd) . zip elts- <$> mapM lookup_gre_fixity elts-- case fixities of- -- There should always be at least one fixity.- -- Something's very wrong if there are no fixity candidates, so panic- [] -> panic "get_ambiguous_fixity: no candidates for a given RdrName"- [ (_, fix):_ ] -> return fix- ambigs -> addErr (ambiguous_fixity_err rdr_name ambigs)- >> return (Fixity NoSourceText minPrecedence InfixL)-- lookup_gre_fixity gre = lookupFixityRn' (gre_name gre) (greOccName gre)-- ambiguous_fixity_err rn ambigs- = vcat [ text "Ambiguous fixity for record field" <+> quotes (ppr rn)- , hang (text "Conflicts: ") 2 . vcat .- map format_ambig $ concat ambigs ]-- format_ambig (elt, fix) = hang (ppr fix)- 2 (pprNameProvenance elt)---{- *********************************************************************-* *- Role annotations-* *-********************************************************************* -}--type RoleAnnotEnv = NameEnv (LRoleAnnotDecl Name)--mkRoleAnnotEnv :: [LRoleAnnotDecl Name] -> RoleAnnotEnv-mkRoleAnnotEnv role_annot_decls- = mkNameEnv [ (name, ra_decl)- | ra_decl <- role_annot_decls- , let name = roleAnnotDeclName (unLoc ra_decl)- , not (isUnboundName name) ]- -- Some of the role annots will be unbound;- -- we don't wish to include these--emptyRoleAnnotEnv :: RoleAnnotEnv-emptyRoleAnnotEnv = emptyNameEnv--lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl Name)-lookupRoleAnnot = lookupNameEnv--getRoleAnnots :: [Name] -> RoleAnnotEnv -> ([LRoleAnnotDecl Name], RoleAnnotEnv)-getRoleAnnots bndrs role_env- = ( mapMaybe (lookupRoleAnnot role_env) bndrs- , delListFromNameEnv role_env bndrs )---{--************************************************************************-* *- Rebindable names- Dealing with rebindable syntax is driven by the- Opt_RebindableSyntax dynamic flag.-- In "deriving" code we don't want to use rebindable syntax- so we switch off the flag locally--* *-************************************************************************--Haskell 98 says that when you say "3" you get the "fromInteger" from the-Standard Prelude, regardless of what is in scope. However, to experiment-with having a language that is less coupled to the standard prelude, we're-trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"-happens to be in scope. Then you can- import Prelude ()- import MyPrelude as Prelude-to get the desired effect.--At the moment this just happens for- * fromInteger, fromRational on literals (in expressions and patterns)- * negate (in expressions)- * minus (arising from n+k patterns)- * "do" notation--We store the relevant Name in the HsSyn tree, in- * HsIntegral/HsFractional/HsIsString- * NegApp- * NPlusKPat- * HsDo-respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,-fromRationalName etc), but the renamer changes this to the appropriate user-name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.--We treat the original (standard) names as free-vars too, because the type checker-checks the type of the user thing against the type of the standard thing.--}--lookupIfThenElse :: RnM (Maybe (SyntaxExpr Name), FreeVars)--- Different to lookupSyntaxName because in the non-rebindable--- case we desugar directly rather than calling an existing function--- Hence the (Maybe (SyntaxExpr Name)) return type-lookupIfThenElse- = do { rebindable_on <- xoptM LangExt.RebindableSyntax- ; if not rebindable_on- then return (Nothing, emptyFVs)- else do { ite <- lookupOccRn (mkVarUnqual (fsLit "ifThenElse"))- ; return ( Just (mkRnSyntaxExpr ite)- , unitFV ite ) } }--lookupSyntaxName' :: Name -- ^ The standard name- -> RnM Name -- ^ Possibly a non-standard name-lookupSyntaxName' std_name- = do { rebindable_on <- xoptM LangExt.RebindableSyntax- ; if not rebindable_on then- return std_name- else- -- Get the similarly named thing from the local environment- lookupOccRn (mkRdrUnqual (nameOccName std_name)) }--lookupSyntaxName :: Name -- The standard name- -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name-lookupSyntaxName std_name- = do { rebindable_on <- xoptM LangExt.RebindableSyntax- ; if not rebindable_on then- return (mkRnSyntaxExpr std_name, emptyFVs)- else- -- Get the similarly named thing from the local environment- do { usr_name <- lookupOccRn (mkRdrUnqual (nameOccName std_name))- ; return (mkRnSyntaxExpr usr_name, unitFV usr_name) } }--lookupSyntaxNames :: [Name] -- Standard names- -> RnM ([HsExpr Name], FreeVars) -- See comments with HsExpr.ReboundNames- -- this works with CmdTop, which wants HsExprs, not SyntaxExprs-lookupSyntaxNames std_names- = do { rebindable_on <- xoptM LangExt.RebindableSyntax- ; if not rebindable_on then- return (map (HsVar . noLoc) std_names, emptyFVs)- else- do { usr_names <- mapM (lookupOccRn . mkRdrUnqual . nameOccName) std_names- ; return (map (HsVar . noLoc) usr_names, mkFVs usr_names) } }--{--*********************************************************-* *-\subsection{Binding}-* *-*********************************************************--}--newLocalBndrRn :: Located RdrName -> RnM Name--- Used for non-top-level binders. These should--- never be qualified.-newLocalBndrRn (L loc rdr_name)- | Just name <- isExact_maybe rdr_name- = return name -- This happens in code generated by Template Haskell- -- See Note [Binders in Template Haskell] in Convert.hs- | otherwise- = do { unless (isUnqual rdr_name)- (addErrAt loc (badQualBndrErr rdr_name))- ; uniq <- newUnique- ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }--newLocalBndrsRn :: [Located RdrName] -> RnM [Name]-newLocalBndrsRn = mapM newLocalBndrRn------------------------bindLocatedLocalsRn :: [Located RdrName]- -> ([Name] -> RnM a)- -> RnM a-bindLocatedLocalsRn rdr_names_w_loc enclosed_scope- = do { checkDupRdrNames rdr_names_w_loc- ; checkShadowedRdrNames rdr_names_w_loc-- -- Make fresh Names and extend the environment- ; names <- newLocalBndrsRn rdr_names_w_loc- ; bindLocalNames names (enclosed_scope names) }--bindLocalNames :: [Name] -> RnM a -> RnM a-bindLocalNames names enclosed_scope- = do { lcl_env <- getLclEnv- ; let th_level = thLevel (tcl_th_ctxt lcl_env)- th_bndrs' = extendNameEnvList (tcl_th_bndrs lcl_env)- [ (n, (NotTopLevel, th_level)) | n <- names ]- rdr_env' = extendLocalRdrEnvList (tcl_rdr lcl_env) names- ; setLclEnv (lcl_env { tcl_th_bndrs = th_bndrs'- , tcl_rdr = rdr_env' })- enclosed_scope }--bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)-bindLocalNamesFV names enclosed_scope- = do { (result, fvs) <- bindLocalNames names enclosed_scope- ; return (result, delFVs names fvs) }----------------------------------------- -- binLocalsFVRn is the same as bindLocalsRn- -- except that it deals with free vars-bindLocatedLocalsFV :: [Located RdrName]- -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)-bindLocatedLocalsFV rdr_names enclosed_scope- = bindLocatedLocalsRn rdr_names $ \ names ->- do (thing, fvs) <- enclosed_scope names- return (thing, delFVs names fvs)-----------------------------------------extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)- -- This function is used only in rnSourceDecl on InstDecl-extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside----------------------------------------checkDupRdrNames :: [Located RdrName] -> RnM ()--- Check for duplicated names in a binding group-checkDupRdrNames rdr_names_w_loc- = mapM_ (dupNamesErr getLoc) dups- where- (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc--checkDupNames :: [Name] -> RnM ()--- Check for duplicated names in a binding group-checkDupNames names = check_dup_names (filterOut isSystemName names)- -- See Note [Binders in Template Haskell] in Convert--check_dup_names :: [Name] -> RnM ()-check_dup_names names- = mapM_ (dupNamesErr nameSrcSpan) dups- where- (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names------------------------checkShadowedRdrNames :: [Located RdrName] -> RnM ()-checkShadowedRdrNames loc_rdr_names- = do { envs <- getRdrEnvs- ; checkShadowedOccs envs get_loc_occ filtered_rdrs }- where- filtered_rdrs = filterOut (isExact . unLoc) loc_rdr_names- -- See Note [Binders in Template Haskell] in Convert- get_loc_occ (L loc rdr) = (loc,rdrNameOcc rdr)--checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()-checkDupAndShadowedNames envs names- = do { check_dup_names filtered_names- ; checkShadowedOccs envs get_loc_occ filtered_names }- where- filtered_names = filterOut isSystemName names- -- See Note [Binders in Template Haskell] in Convert- get_loc_occ name = (nameSrcSpan name, nameOccName name)----------------------------------------checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv)- -> (a -> (SrcSpan, OccName))- -> [a] -> RnM ()-checkShadowedOccs (global_env,local_env) get_loc_occ ns- = whenWOptM Opt_WarnNameShadowing $- do { traceRn "checkShadowedOccs:shadow" (ppr (map get_loc_occ ns))- ; mapM_ check_shadow ns }- where- check_shadow n- | startsWithUnderscore occ = return () -- Do not report shadowing for "_x"- -- See Trac #3262- | Just n <- mb_local = complain [text "bound at" <+> ppr (nameSrcLoc n)]- | otherwise = do { gres' <- filterM is_shadowed_gre gres- ; complain (map pprNameProvenance gres') }- where- (loc,occ) = get_loc_occ n- mb_local = lookupLocalRdrOcc local_env occ- gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env- -- Make an Unqualified RdrName and look that up, so that- -- we don't find any GREs that are in scope qualified-only-- complain [] = return ()- complain pp_locs = addWarnAt (Reason Opt_WarnNameShadowing)- loc- (shadowedNameWarn occ pp_locs)-- is_shadowed_gre :: GlobalRdrElt -> RnM Bool- -- Returns False for record selectors that are shadowed, when- -- punning or wild-cards are on (cf Trac #2723)- is_shadowed_gre gre | isRecFldGRE gre- = do { dflags <- getDynFlags- ; return $ not (xopt LangExt.RecordPuns dflags- || xopt LangExt.RecordWildCards dflags) }- is_shadowed_gre _other = return True--{--************************************************************************-* *- What to do when a lookup fails-* *-************************************************************************--}--data WhereLooking = WL_Any -- Any binding- | WL_Global -- Any top-level binding (local or imported)- | WL_LocalTop -- Any top-level binding in this module--reportUnboundName :: RdrName -> RnM Name-reportUnboundName rdr = unboundName WL_Any rdr--unboundName :: WhereLooking -> RdrName -> RnM Name-unboundName wl rdr = unboundNameX wl rdr Outputable.empty--unboundNameX :: WhereLooking -> RdrName -> SDoc -> RnM Name-unboundNameX where_look rdr_name extra- = do { dflags <- getDynFlags- ; let show_helpful_errors = gopt Opt_HelpfulErrors dflags- what = pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))- err = unknownNameErr what rdr_name $$ extra- ; if not show_helpful_errors- then addErr err- else do { local_env <- getLocalRdrEnv- ; global_env <- getGlobalRdrEnv- ; impInfo <- getImports- ; let suggestions = unknownNameSuggestions_ where_look- dflags global_env local_env impInfo rdr_name- ; addErr (err $$ suggestions) }- ; return (mkUnboundNameRdr rdr_name) }--unknownNameErr :: SDoc -> RdrName -> SDoc-unknownNameErr what rdr_name- = vcat [ hang (text "Not in scope:")- 2 (what <+> quotes (ppr rdr_name))- , extra ]- where- extra | rdr_name == forall_tv_RDR = perhapsForallMsg- | otherwise = Outputable.empty--type HowInScope = Either SrcSpan ImpDeclSpec- -- Left loc => locally bound at loc- -- Right ispec => imported as specified by ispec----- | Called from the typechecker (TcErrors) when we find an unbound variable-unknownNameSuggestions :: DynFlags- -> GlobalRdrEnv -> LocalRdrEnv -> ImportAvails- -> RdrName -> SDoc-unknownNameSuggestions = unknownNameSuggestions_ WL_Any--unknownNameSuggestions_ :: WhereLooking -> DynFlags- -> GlobalRdrEnv -> LocalRdrEnv -> ImportAvails- -> RdrName -> SDoc-unknownNameSuggestions_ where_look dflags global_env local_env imports tried_rdr_name =- similarNameSuggestions where_look dflags global_env local_env tried_rdr_name $$- importSuggestions dflags imports tried_rdr_name---similarNameSuggestions :: WhereLooking -> DynFlags- -> GlobalRdrEnv -> LocalRdrEnv- -> RdrName -> SDoc-similarNameSuggestions where_look dflags global_env- local_env tried_rdr_name- = case suggest of- [] -> Outputable.empty- [p] -> perhaps <+> pp_item p- ps -> sep [ perhaps <+> text "one of these:"- , nest 2 (pprWithCommas pp_item ps) ]- where- all_possibilities :: [(String, (RdrName, HowInScope))]- all_possibilities- = [ (showPpr dflags r, (r, Left loc))- | (r,loc) <- local_possibilities local_env ]- ++ [ (showPpr dflags r, rp) | (r, rp) <- global_possibilities global_env ]-- suggest = fuzzyLookup (showPpr dflags tried_rdr_name) all_possibilities- perhaps = text "Perhaps you meant"-- pp_item :: (RdrName, HowInScope) -> SDoc- pp_item (rdr, Left loc) = pp_ns rdr <+> quotes (ppr rdr) <+> loc' -- Locally defined- where loc' = case loc of- UnhelpfulSpan l -> parens (ppr l)- RealSrcSpan l -> parens (text "line" <+> int (srcSpanStartLine l))- pp_item (rdr, Right is) = pp_ns rdr <+> quotes (ppr rdr) <+> -- Imported- parens (text "imported from" <+> ppr (is_mod is))-- pp_ns :: RdrName -> SDoc- pp_ns rdr | ns /= tried_ns = pprNameSpace ns- | otherwise = Outputable.empty- where ns = rdrNameSpace rdr-- tried_occ = rdrNameOcc tried_rdr_name- tried_is_sym = isSymOcc tried_occ- tried_ns = occNameSpace tried_occ- tried_is_qual = isQual tried_rdr_name-- correct_name_space occ = nameSpacesRelated (occNameSpace occ) tried_ns- && isSymOcc occ == tried_is_sym- -- Treat operator and non-operators as non-matching- -- This heuristic avoids things like- -- Not in scope 'f'; perhaps you meant '+' (from Prelude)-- local_ok = case where_look of { WL_Any -> True; _ -> False }- local_possibilities :: LocalRdrEnv -> [(RdrName, SrcSpan)]- local_possibilities env- | tried_is_qual = []- | not local_ok = []- | otherwise = [ (mkRdrUnqual occ, nameSrcSpan name)- | name <- localRdrEnvElts env- , let occ = nameOccName name- , correct_name_space occ]-- gre_ok :: GlobalRdrElt -> Bool- gre_ok = case where_look of- WL_LocalTop -> isLocalGRE- _ -> \_ -> True-- global_possibilities :: GlobalRdrEnv -> [(RdrName, (RdrName, HowInScope))]- global_possibilities global_env- | tried_is_qual = [ (rdr_qual, (rdr_qual, how))- | gre <- globalRdrEnvElts global_env- , gre_ok gre- , let name = gre_name gre- occ = nameOccName name- , correct_name_space occ- , (mod, how) <- quals_in_scope gre- , let rdr_qual = mkRdrQual mod occ ]-- | otherwise = [ (rdr_unqual, pair)- | gre <- globalRdrEnvElts global_env- , gre_ok gre- , let name = gre_name gre- occ = nameOccName name- rdr_unqual = mkRdrUnqual occ- , correct_name_space occ- , pair <- case (unquals_in_scope gre, quals_only gre) of- (how:_, _) -> [ (rdr_unqual, how) ]- ([], pr:_) -> [ pr ] -- See Note [Only-quals]- ([], []) -> [] ]-- -- Note [Only-quals]- -- The second alternative returns those names with the same- -- OccName as the one we tried, but live in *qualified* imports- -- e.g. if you have:- --- -- > import qualified Data.Map as Map- -- > foo :: Map- --- -- then we suggest @Map.Map@.-- --------------------- unquals_in_scope :: GlobalRdrElt -> [HowInScope]- unquals_in_scope (GRE { gre_name = n, gre_lcl = lcl, gre_imp = is })- | lcl = [ Left (nameSrcSpan n) ]- | otherwise = [ Right ispec- | i <- is, let ispec = is_decl i- , not (is_qual ispec) ]-- --------------------- quals_in_scope :: GlobalRdrElt -> [(ModuleName, HowInScope)]- -- Ones for which the qualified version is in scope- quals_in_scope (GRE { gre_name = n, gre_lcl = lcl, gre_imp = is })- | lcl = case nameModule_maybe n of- Nothing -> []- Just m -> [(moduleName m, Left (nameSrcSpan n))]- | otherwise = [ (is_as ispec, Right ispec)- | i <- is, let ispec = is_decl i ]-- --------------------- quals_only :: GlobalRdrElt -> [(RdrName, HowInScope)]- -- Ones for which *only* the qualified version is in scope- quals_only (GRE { gre_name = n, gre_imp = is })- = [ (mkRdrQual (is_as ispec) (nameOccName n), Right ispec)- | i <- is, let ispec = is_decl i, is_qual ispec ]---- | Generate helpful suggestions if a qualified name Mod.foo is not in scope.-importSuggestions :: DynFlags -> ImportAvails -> RdrName -> SDoc-importSuggestions _dflags imports rdr_name- | not (isQual rdr_name || isUnqual rdr_name) = Outputable.empty- | null interesting_imports- , Just name <- mod_name- = hsep- [ text "No module named"- , quotes (ppr name)- , text "is imported."- ]- | is_qualified- , null helpful_imports- , [(mod,_)] <- interesting_imports- = hsep- [ text "Module"- , quotes (ppr mod)- , text "does not export"- , quotes (ppr occ_name) <> dot- ]- | is_qualified- , null helpful_imports- , mods <- map fst interesting_imports- = hsep- [ text "Neither"- , quotedListWithNor (map ppr mods)- , text "exports"- , quotes (ppr occ_name) <> dot- ]- | [(mod,imv)] <- helpful_imports_non_hiding- = fsep- [ text "Perhaps you want to add"- , quotes (ppr occ_name)- , text "to the import list"- , text "in the import of"- , quotes (ppr mod)- , parens (ppr (imv_span imv)) <> dot- ]- | not (null helpful_imports_non_hiding)- = fsep- [ text "Perhaps you want to add"- , quotes (ppr occ_name)- , text "to one of these import lists:"- ]- $$- nest 2 (vcat- [ quotes (ppr mod) <+> parens (ppr (imv_span imv))- | (mod,imv) <- helpful_imports_non_hiding- ])- | [(mod,imv)] <- helpful_imports_hiding- = fsep- [ text "Perhaps you want to remove"- , quotes (ppr occ_name)- , text "from the explicit hiding list"- , text "in the import of"- , quotes (ppr mod)- , parens (ppr (imv_span imv)) <> dot- ]- | not (null helpful_imports_hiding)- = fsep- [ text "Perhaps you want to remove"- , quotes (ppr occ_name)- , text "from the hiding clauses"- , text "in one of these imports:"- ]- $$- nest 2 (vcat- [ quotes (ppr mod) <+> parens (ppr (imv_span imv))- | (mod,imv) <- helpful_imports_hiding- ])- | otherwise- = Outputable.empty- where- is_qualified = isQual rdr_name- (mod_name, occ_name) = case rdr_name of- Unqual occ_name -> (Nothing, occ_name)- Qual mod_name occ_name -> (Just mod_name, occ_name)- _ -> error "importSuggestions: dead code"--- -- What import statements provide "Mod" at all- -- or, if this is an unqualified name, are not qualified imports- interesting_imports = [ (mod, imp)- | (mod, mod_imports) <- moduleEnvToList (imp_mods imports)- , Just imp <- return $ pick (importedByUser mod_imports)- ]-- -- We want to keep only one for each original module; preferably one with an- -- explicit import list (for no particularly good reason)- pick :: [ImportedModsVal] -> Maybe ImportedModsVal- pick = listToMaybe . sortBy (compare `on` prefer) . filter select- where select imv = case mod_name of Just name -> imv_name imv == name- Nothing -> not (imv_qualified imv)- prefer imv = (imv_is_hiding imv, imv_span imv)-- -- Which of these would export a 'foo'- -- (all of these are restricted imports, because if they were not, we- -- wouldn't have an out-of-scope error in the first place)- helpful_imports = filter helpful interesting_imports- where helpful (_,imv)- = not . null $ lookupGlobalRdrEnv (imv_all_exports imv) occ_name-- -- Which of these do that because of an explicit hiding list resp. an- -- explicit import list- (helpful_imports_hiding, helpful_imports_non_hiding)- = partition (imv_is_hiding . snd) helpful_imports--{--************************************************************************-* *-\subsection{Free variable manipulation}-* *-************************************************************************--}---- A useful utility-addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)-addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside- ; return (res, fvs1 `plusFV` fvs2) }--mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)-mapFvRn f xs = do stuff <- mapM f xs- case unzip stuff of- (ys, fvs_s) -> return (ys, plusFVs fvs_s)--mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)-mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)-mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }---- because some of the rename functions are CPSed:--- maps the function across the list from left to right;--- collects all the free vars into one set-mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)- -> [a] -> ([b] -> RnM c) -> RnM c--mapFvRnCPS _ [] cont = cont []-mapFvRnCPS f (x:xs) cont = f x $ \ x' ->- mapFvRnCPS f xs $ \ xs' ->- cont (x':xs')--{--************************************************************************-* *-\subsection{Envt utility functions}-* *-************************************************************************--}--warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()-warnUnusedTopBinds gres- = whenWOptM Opt_WarnUnusedTopBinds- $ do env <- getGblEnv- let isBoot = tcg_src env == HsBootFile- let noParent gre = case gre_par gre of- NoParent -> True- _ -> False- -- Don't warn about unused bindings with parents in- -- .hs-boot files, as you are sometimes required to give- -- unused bindings (trac #3449).- -- HOWEVER, in a signature file, you are never obligated to put a- -- definition in the main text. Thus, if you define something- -- and forget to export it, we really DO want to warn.- gres' = if isBoot then filter noParent gres- else gres- warnUnusedGREs gres'--warnUnusedLocalBinds, warnUnusedMatches, warnUnusedTypePatterns- :: [Name] -> FreeVars -> RnM ()-warnUnusedLocalBinds = check_unused Opt_WarnUnusedLocalBinds-warnUnusedMatches = check_unused Opt_WarnUnusedMatches-warnUnusedTypePatterns = check_unused Opt_WarnUnusedTypePatterns--check_unused :: WarningFlag -> [Name] -> FreeVars -> RnM ()-check_unused flag bound_names used_names- = whenWOptM flag (warnUnused flag (filterOut (`elemNameSet` used_names)- bound_names))------------------------------ Helpers-warnUnusedGREs :: [GlobalRdrElt] -> RnM ()-warnUnusedGREs gres = mapM_ warnUnusedGRE gres--warnUnused :: WarningFlag -> [Name] -> RnM ()-warnUnused flag names = do- fld_env <- mkFieldEnv <$> getGlobalRdrEnv- mapM_ (warnUnused1 flag fld_env) names--warnUnused1 :: WarningFlag -> NameEnv (FieldLabelString, Name) -> Name -> RnM ()-warnUnused1 flag fld_env name- = when (reportable name occ) $- addUnusedWarning flag- occ (nameSrcSpan name)- (text "Defined but not used")- where- occ = case lookupNameEnv fld_env name of- Just (fl, _) -> mkVarOccFS fl- Nothing -> nameOccName name--warnUnusedGRE :: GlobalRdrElt -> RnM ()-warnUnusedGRE gre@(GRE { gre_name = name, gre_lcl = lcl, gre_imp = is })- | lcl = do fld_env <- mkFieldEnv <$> getGlobalRdrEnv- warnUnused1 Opt_WarnUnusedTopBinds fld_env name- | otherwise = when (reportable name occ) (mapM_ warn is)- where- occ = greOccName gre- warn spec = addUnusedWarning Opt_WarnUnusedTopBinds occ span msg- where- span = importSpecLoc spec- pp_mod = quotes (ppr (importSpecModule spec))- msg = text "Imported from" <+> pp_mod <+> ptext (sLit "but not used")---- | Make a map from selector names to field labels and parent tycon--- names, to be used when reporting unused record fields.-mkFieldEnv :: GlobalRdrEnv -> NameEnv (FieldLabelString, Name)-mkFieldEnv rdr_env = mkNameEnv [ (gre_name gre, (lbl, par_is (gre_par gre)))- | gres <- occEnvElts rdr_env- , gre <- gres- , Just lbl <- [greLabel gre]- ]---- | Should we report the fact that this 'Name' is unused? The--- 'OccName' may differ from 'nameOccName' due to--- DuplicateRecordFields.-reportable :: Name -> OccName -> Bool-reportable name occ- | isWiredInName name = False -- Don't report unused wired-in names- -- Otherwise we get a zillion warnings- -- from Data.Tuple- | otherwise = not (startsWithUnderscore occ)--addUnusedWarning :: WarningFlag -> OccName -> SrcSpan -> SDoc -> RnM ()-addUnusedWarning flag occ span msg- = addWarnAt (Reason flag) span $- sep [msg <> colon,- nest 2 $ pprNonVarNameSpace (occNameSpace occ)- <+> quotes (ppr occ)]--addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()-addNameClashErrRn rdr_name gres- | all isLocalGRE gres && not (all isRecFldGRE gres)- -- If there are two or more *local* defns, we'll have reported- = return () -- that already, and we don't want an error cascade- | otherwise- = addErr (vcat [text "Ambiguous occurrence" <+> quotes (ppr rdr_name),- text "It could refer to" <+> vcat (msg1 : msgs)])- where- (np1:nps) = gres- msg1 = ptext (sLit "either") <+> mk_ref np1- msgs = [text " or" <+> mk_ref np | np <- nps]- mk_ref gre = sep [nom <> comma, pprNameProvenance gre]- where nom = case gre_par gre of- FldParent { par_lbl = Just lbl } -> text "the field" <+> quotes (ppr lbl)- _ -> quotes (ppr (gre_name gre))--shadowedNameWarn :: OccName -> [SDoc] -> SDoc-shadowedNameWarn occ shadowed_locs- = sep [text "This binding for" <+> quotes (ppr occ)- <+> text "shadows the existing binding" <> plural shadowed_locs,- nest 2 (vcat shadowed_locs)]--perhapsForallMsg :: SDoc-perhapsForallMsg- = vcat [ text "Perhaps you intended to use ExplicitForAll or similar flag"- , text "to enable explicit-forall syntax: forall <tvs>. <type>"]--unknownSubordinateErr :: SDoc -> RdrName -> SDoc-unknownSubordinateErr doc op -- Doc is "method of class" or- -- "field of constructor"- = quotes (ppr op) <+> text "is not a (visible)" <+> doc--badOrigBinding :: RdrName -> SDoc-badOrigBinding name- = text "Illegal binding of built-in syntax:" <+> ppr (rdrNameOcc name)- -- The rdrNameOcc is because we don't want to print Prelude.(,)--dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()-dupNamesErr get_loc names- = addErrAt big_loc $- vcat [text "Conflicting definitions for" <+> quotes (ppr (head names)),- locations]- where- locs = map get_loc names- big_loc = foldr1 combineSrcSpans locs- locations = text "Bound at:" <+> vcat (map ppr (sort locs))--kindSigErr :: Outputable a => a -> SDoc-kindSigErr thing- = hang (text "Illegal kind signature for" <+> quotes (ppr thing))- 2 (text "Perhaps you intended to use KindSignatures")--badQualBndrErr :: RdrName -> SDoc-badQualBndrErr rdr_name- = text "Qualified name in binding position:" <+> ppr rdr_name--opDeclErr :: RdrName -> SDoc-opDeclErr n- = hang (text "Illegal declaration of a type or class operator" <+> quotes (ppr n))- 2 (text "Use TypeOperators to declare operators in type and declarations")--checkTupSize :: Int -> RnM ()-checkTupSize tup_size- | tup_size <= mAX_TUPLE_SIZE- = return ()- | otherwise- = addErr (sep [text "A" <+> int tup_size <> ptext (sLit "-tuple is too large for GHC"),- nest 2 (parens (text "max size is" <+> int mAX_TUPLE_SIZE)),- nest 2 (text "Workaround: use nested tuples or define a data type")])--{--************************************************************************-* *-\subsection{Contexts for renaming errors}-* *-************************************************************************--}---- AZ:TODO: Change these all to be Name instead of RdrName.--- Merge TcType.UserTypeContext in to it.-data HsDocContext- = TypeSigCtx SDoc- | PatCtx- | SpecInstSigCtx- | DefaultDeclCtx- | ForeignDeclCtx (Located RdrName)- | DerivDeclCtx- | RuleCtx FastString- | TyDataCtx (Located RdrName)- | TySynCtx (Located RdrName)- | TyFamilyCtx (Located RdrName)- | FamPatCtx (Located RdrName) -- The patterns of a type/data family instance- | ConDeclCtx [Located Name]- | ClassDeclCtx (Located RdrName)- | ExprWithTySigCtx- | TypBrCtx- | HsTypeCtx- | GHCiCtx- | SpliceTypeCtx (LHsType RdrName)- | ClassInstanceCtx- | VectDeclCtx (Located RdrName)- | GenericCtx SDoc -- Maybe we want to use this more!--withHsDocContext :: HsDocContext -> SDoc -> SDoc-withHsDocContext ctxt doc = doc $$ inHsDocContext ctxt--inHsDocContext :: HsDocContext -> SDoc-inHsDocContext ctxt = text "In" <+> pprHsDocContext ctxt--pprHsDocContext :: HsDocContext -> SDoc-pprHsDocContext (GenericCtx doc) = doc-pprHsDocContext (TypeSigCtx doc) = text "the type signature for" <+> doc-pprHsDocContext PatCtx = text "a pattern type-signature"-pprHsDocContext SpecInstSigCtx = text "a SPECIALISE instance pragma"-pprHsDocContext DefaultDeclCtx = text "a `default' declaration"-pprHsDocContext DerivDeclCtx = text "a deriving declaration"-pprHsDocContext (RuleCtx name) = text "the transformation rule" <+> ftext name-pprHsDocContext (TyDataCtx tycon) = text "the data type declaration for" <+> quotes (ppr tycon)-pprHsDocContext (FamPatCtx tycon) = text "a type pattern of family instance for" <+> quotes (ppr tycon)-pprHsDocContext (TySynCtx name) = text "the declaration for type synonym" <+> quotes (ppr name)-pprHsDocContext (TyFamilyCtx name) = text "the declaration for type family" <+> quotes (ppr name)-pprHsDocContext (ClassDeclCtx name) = text "the declaration for class" <+> quotes (ppr name)-pprHsDocContext ExprWithTySigCtx = text "an expression type signature"-pprHsDocContext TypBrCtx = text "a Template-Haskell quoted type"-pprHsDocContext HsTypeCtx = text "a type argument"-pprHsDocContext GHCiCtx = text "GHCi input"-pprHsDocContext (SpliceTypeCtx hs_ty) = text "the spliced type" <+> quotes (ppr hs_ty)-pprHsDocContext ClassInstanceCtx = text "TcSplice.reifyInstances"--pprHsDocContext (ForeignDeclCtx name)- = text "the foreign declaration for" <+> quotes (ppr name)-pprHsDocContext (ConDeclCtx [name])- = text "the definition of data constructor" <+> quotes (ppr name)-pprHsDocContext (ConDeclCtx names)- = text "the definition of data constructors" <+> interpp'SP names-pprHsDocContext (VectDeclCtx tycon)- = text "the VECTORISE pragma for type constructor" <+> quotes (ppr tycon)+RnEnv contains functions which convert RdrNames into Names.++-}++{-# LANGUAGE CPP, MultiWayIf, NamedFieldPuns #-}++module RnEnv (+ newTopSrcBinder,+ lookupLocatedTopBndrRn, lookupTopBndrRn,+ lookupLocatedOccRn, lookupOccRn, lookupOccRn_maybe,+ lookupLocalOccRn_maybe, lookupInfoOccRn,+ lookupLocalOccThLvl_maybe, lookupLocalOccRn,+ lookupTypeOccRn, lookupKindOccRn,+ lookupGlobalOccRn, lookupGlobalOccRn_maybe,+ lookupOccRn_overloaded, lookupGlobalOccRn_overloaded, lookupExactOcc,++ ChildLookupResult(..),+ lookupSubBndrOcc_helper,+ combineChildLookupResult, -- Called by lookupChildrenExport++ HsSigCtxt(..), lookupLocalTcNames, lookupSigOccRn,+ lookupSigCtxtOccRn,++ lookupInstDeclBndr, lookupRecFieldOcc, lookupFamInstName,+ lookupConstructorFields,++ lookupGreAvailRn,++ -- Rebindable Syntax+ lookupSyntaxName, lookupSyntaxName', lookupSyntaxNames,+ lookupIfThenElse,++ -- Constructing usage information+ addUsedGRE, addUsedGREs, addUsedDataCons,++++ dataTcOccs, --TODO: Move this somewhere, into utils?++ ) where++#include "HsVersions.h"++import GhcPrelude++import LoadIface ( loadInterfaceForName, loadSrcInterface_maybe )+import IfaceEnv+import HsSyn+import RdrName+import HscTypes+import TcEnv+import TcRnMonad+import RdrHsSyn ( setRdrNameSpace )+import TysWiredIn+import Name+import NameSet+import NameEnv+import Avail+import Module+import ConLike+import DataCon+import TyCon+import ErrUtils ( MsgDoc )+import PrelNames ( rOOT_MAIN )+import BasicTypes ( pprWarningTxtForMsg, TopLevelFlag(..))+import SrcLoc+import Outputable+import Util+import Maybes+import DynFlags+import FastString+import Control.Monad+import ListSetOps ( minusList )+import qualified GHC.LanguageExtensions as LangExt+import RnUnbound+import RnUtils+import Data.Maybe (isJust)+import qualified Data.Semigroup as Semi++{-+*********************************************************+* *+ Source-code binders+* *+*********************************************************++Note [Signature lazy interface loading]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++GHC's lazy interface loading can be a bit confusing, so this Note is an+empirical description of what happens in one interesting case. When+compiling a signature module against an its implementation, we do NOT+load interface files associated with its names until after the type+checking phase. For example:++ module ASig where+ data T+ f :: T -> T++Suppose we compile this with -sig-of "A is ASig":++ module B where+ data T = T+ f T = T++ module A(module B) where+ import B++During type checking, we'll load A.hi because we need to know what the+RdrEnv for the module is, but we DO NOT load the interface for B.hi!+It's wholly unnecessary: our local definition 'data T' in ASig is all+the information we need to finish type checking. This is contrast to+type checking of ordinary Haskell files, in which we would not have the+local definition "data T" and would need to consult B.hi immediately.+(Also, this situation never occurs for hs-boot files, since you're not+allowed to reexport from another module.)++After type checking, we then check that the types we provided are+consistent with the backing implementation (in checkHiBootOrHsigIface).+At this point, B.hi is loaded, because we need something to compare+against.++I discovered this behavior when trying to figure out why type class+instances for Data.Map weren't in the EPS when I was type checking a+test very much like ASig (sigof02dm): the associated interface hadn't+been loaded yet! (The larger issue is a moot point, since an instance+declared in a signature can never be a duplicate.)++This behavior might change in the future. Consider this+alternate module B:++ module B where+ {-# DEPRECATED T, f "Don't use" #-}+ data T = T+ f T = T++One might conceivably want to report deprecation warnings when compiling+ASig with -sig-of B, in which case we need to look at B.hi to find the+deprecation warnings during renaming. At the moment, you don't get any+warning until you use the identifier further downstream. This would+require adjusting addUsedGRE so that during signature compilation,+we do not report deprecation warnings for LocalDef. See also+Note [Handling of deprecations]+-}++newTopSrcBinder :: Located RdrName -> RnM Name+newTopSrcBinder (L loc rdr_name)+ | Just name <- isExact_maybe rdr_name+ = -- This is here to catch+ -- (a) Exact-name binders created by Template Haskell+ -- (b) The PrelBase defn of (say) [] and similar, for which+ -- the parser reads the special syntax and returns an Exact RdrName+ -- We are at a binding site for the name, so check first that it+ -- the current module is the correct one; otherwise GHC can get+ -- very confused indeed. This test rejects code like+ -- data T = (,) Int Int+ -- unless we are in GHC.Tup+ if isExternalName name then+ do { this_mod <- getModule+ ; unless (this_mod == nameModule name)+ (addErrAt loc (badOrigBinding rdr_name))+ ; return name }+ else -- See Note [Binders in Template Haskell] in Convert.hs+ do { this_mod <- getModule+ ; externaliseName this_mod name }++ | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name+ = do { this_mod <- getModule+ ; unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)+ (addErrAt loc (badOrigBinding rdr_name))+ -- When reading External Core we get Orig names as binders,+ -- but they should agree with the module gotten from the monad+ --+ -- We can get built-in syntax showing up here too, sadly. If you type+ -- data T = (,,,)+ -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon+ -- uses setRdrNameSpace to make it into a data constructors. At that point+ -- the nice Exact name for the TyCon gets swizzled to an Orig name.+ -- Hence the badOrigBinding error message.+ --+ -- Except for the ":Main.main = ..." definition inserted into+ -- the Main module; ugh!++ -- Because of this latter case, we call newGlobalBinder with a module from+ -- the RdrName, not from the environment. In principle, it'd be fine to+ -- have an arbitrary mixture of external core definitions in a single module,+ -- (apart from module-initialisation issues, perhaps).+ ; newGlobalBinder rdr_mod rdr_occ loc }++ | otherwise+ = do { when (isQual rdr_name)+ (addErrAt loc (badQualBndrErr rdr_name))+ -- Binders should not be qualified; if they are, and with a different+ -- module name, we we get a confusing "M.T is not in scope" error later++ ; stage <- getStage+ ; if isBrackStage stage then+ -- We are inside a TH bracket, so make an *Internal* name+ -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames+ do { uniq <- newUnique+ ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }+ else+ do { this_mod <- getModule+ ; traceRn "newTopSrcBinder" (ppr this_mod $$ ppr rdr_name $$ ppr loc)+ ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }+ }++{-+*********************************************************+* *+ Source code occurrences+* *+*********************************************************++Looking up a name in the RnEnv.++Note [Type and class operator definitions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We want to reject all of these unless we have -XTypeOperators (Trac #3265)+ data a :*: b = ...+ class a :*: b where ...+ data (:*:) a b = ....+ class (:*:) a b where ...+The latter two mean that we are not just looking for a+*syntactically-infix* declaration, but one that uses an operator+OccName. We use OccName.isSymOcc to detect that case, which isn't+terribly efficient, but there seems to be no better way.+-}++-- Can be made to not be exposed+-- Only used unwrapped in rnAnnProvenance+lookupTopBndrRn :: RdrName -> RnM Name+lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n+ case nopt of+ Just n' -> return n'+ Nothing -> do traceRn "lookupTopBndrRn fail" (ppr n)+ unboundName WL_LocalTop n++lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)+lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn++lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)+-- Look up a top-level source-code binder. We may be looking up an unqualified 'f',+-- and there may be several imported 'f's too, which must not confuse us.+-- For example, this is OK:+-- import Foo( f )+-- infix 9 f -- The 'f' here does not need to be qualified+-- f x = x -- Nor here, of course+-- So we have to filter out the non-local ones.+--+-- A separate function (importsFromLocalDecls) reports duplicate top level+-- decls, so here it's safe just to choose an arbitrary one.+--+-- There should never be a qualified name in a binding position in Haskell,+-- but there can be if we have read in an external-Core file.+-- The Haskell parser checks for the illegal qualified name in Haskell+-- source files, so we don't need to do so here.++lookupTopBndrRn_maybe rdr_name =+ lookupExactOrOrig rdr_name Just $+ do { -- Check for operators in type or class declarations+ -- See Note [Type and class operator definitions]+ let occ = rdrNameOcc rdr_name+ ; when (isTcOcc occ && isSymOcc occ)+ (do { op_ok <- xoptM LangExt.TypeOperators+ ; unless op_ok (addErr (opDeclErr rdr_name)) })++ ; env <- getGlobalRdrEnv+ ; case filter isLocalGRE (lookupGRE_RdrName rdr_name env) of+ [gre] -> return (Just (gre_name gre))+ _ -> return Nothing -- Ambiguous (can't happen) or unbound+ }++-----------------------------------------------+-- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].+-- This adds an error if the name cannot be found.+lookupExactOcc :: Name -> RnM Name+lookupExactOcc name+ = do { result <- lookupExactOcc_either name+ ; case result of+ Left err -> do { addErr err+ ; return name }+ Right name' -> return name' }++-- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].+-- This never adds an error, but it may return one.+lookupExactOcc_either :: Name -> RnM (Either MsgDoc Name)+-- See Note [Looking up Exact RdrNames]+lookupExactOcc_either name+ | Just thing <- wiredInNameTyThing_maybe name+ , Just tycon <- case thing of+ ATyCon tc -> Just tc+ AConLike (RealDataCon dc) -> Just (dataConTyCon dc)+ _ -> Nothing+ , isTupleTyCon tycon+ = do { checkTupSize (tyConArity tycon)+ ; return (Right name) }++ | isExternalName name+ = return (Right name)++ | otherwise+ = do { env <- getGlobalRdrEnv+ ; let -- See Note [Splicing Exact names]+ main_occ = nameOccName name+ demoted_occs = case demoteOccName main_occ of+ Just occ -> [occ]+ Nothing -> []+ gres = [ gre | occ <- main_occ : demoted_occs+ , gre <- lookupGlobalRdrEnv env occ+ , gre_name gre == name ]+ ; case gres of+ [gre] -> return (Right (gre_name gre))++ [] -> -- See Note [Splicing Exact names]+ do { lcl_env <- getLocalRdrEnv+ ; if name `inLocalRdrEnvScope` lcl_env+ then return (Right name)+ else+ do { th_topnames_var <- fmap tcg_th_topnames getGblEnv+ ; th_topnames <- readTcRef th_topnames_var+ ; if name `elemNameSet` th_topnames+ then return (Right name)+ else return (Left exact_nm_err)+ }+ }+ gres -> return (Left (sameNameErr gres)) -- Ugh! See Note [Template Haskell ambiguity]+ }+ where+ exact_nm_err = hang (text "The exact Name" <+> quotes (ppr name) <+> ptext (sLit "is not in scope"))+ 2 (vcat [ text "Probable cause: you used a unique Template Haskell name (NameU), "+ , text "perhaps via newName, but did not bind it"+ , text "If that's it, then -ddump-splices might be useful" ])++sameNameErr :: [GlobalRdrElt] -> MsgDoc+sameNameErr [] = panic "addSameNameErr: empty list"+sameNameErr gres@(_ : _)+ = hang (text "Same exact name in multiple name-spaces:")+ 2 (vcat (map pp_one sorted_names) $$ th_hint)+ where+ sorted_names = sortWith nameSrcLoc (map gre_name gres)+ pp_one name+ = hang (pprNameSpace (occNameSpace (getOccName name))+ <+> quotes (ppr name) <> comma)+ 2 (text "declared at:" <+> ppr (nameSrcLoc name))++ th_hint = vcat [ text "Probable cause: you bound a unique Template Haskell name (NameU),"+ , text "perhaps via newName, in different name-spaces."+ , text "If that's it, then -ddump-splices might be useful" ]+++-----------------------------------------------+lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name+-- This is called on the method name on the left-hand side of an+-- instance declaration binding. eg. instance Functor T where+-- fmap = ...+-- ^^^^ called on this+-- Regardless of how many unqualified fmaps are in scope, we want+-- the one that comes from the Functor class.+--+-- Furthermore, note that we take no account of whether the+-- name is only in scope qualified. I.e. even if method op is+-- in scope as M.op, we still allow plain 'op' on the LHS of+-- an instance decl+--+-- The "what" parameter says "method" or "associated type",+-- depending on what we are looking up+lookupInstDeclBndr cls what rdr+ = do { when (isQual rdr)+ (addErr (badQualBndrErr rdr))+ -- In an instance decl you aren't allowed+ -- to use a qualified name for the method+ -- (Although it'd make perfect sense.)+ ; mb_name <- lookupSubBndrOcc+ False -- False => we don't give deprecated+ -- warnings when a deprecated class+ -- method is defined. We only warn+ -- when it's used+ cls doc rdr+ ; case mb_name of+ Left err -> do { addErr err; return (mkUnboundNameRdr rdr) }+ Right nm -> return nm }+ where+ doc = what <+> text "of class" <+> quotes (ppr cls)++-----------------------------------------------+lookupFamInstName :: Maybe Name -> Located RdrName+ -> RnM (Located Name)+-- Used for TyData and TySynonym family instances only,+-- See Note [Family instance binders]+lookupFamInstName (Just cls) tc_rdr -- Associated type; c.f RnBinds.rnMethodBind+ = wrapLocM (lookupInstDeclBndr cls (text "associated type")) tc_rdr+lookupFamInstName Nothing tc_rdr -- Family instance; tc_rdr is an *occurrence*+ = lookupLocatedOccRn tc_rdr++-----------------------------------------------+lookupConstructorFields :: Name -> RnM [FieldLabel]+-- Look up the fields of a given constructor+-- * For constructors from this module, use the record field env,+-- which is itself gathered from the (as yet un-typechecked)+-- data type decls+--+-- * For constructors from imported modules, use the *type* environment+-- since imported modles are already compiled, the info is conveniently+-- right there++lookupConstructorFields con_name+ = do { this_mod <- getModule+ ; if nameIsLocalOrFrom this_mod con_name then+ do { field_env <- getRecFieldEnv+ ; traceTc "lookupCF" (ppr con_name $$ ppr (lookupNameEnv field_env con_name) $$ ppr field_env)+ ; return (lookupNameEnv field_env con_name `orElse` []) }+ else+ do { con <- tcLookupConLike con_name+ ; traceTc "lookupCF 2" (ppr con)+ ; return (conLikeFieldLabels con) } }+++-- In CPS style as `RnM r` is monadic+lookupExactOrOrig :: RdrName -> (Name -> r) -> RnM r -> RnM r+lookupExactOrOrig rdr_name res k+ | Just n <- isExact_maybe rdr_name -- This happens in derived code+ = res <$> lookupExactOcc n+ | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name+ = res <$> lookupOrig rdr_mod rdr_occ+ | otherwise = k++++-----------------------------------------------+-- Used for record construction and pattern matching+-- When the -XDisambiguateRecordFields flag is on, take account of the+-- constructor name to disambiguate which field to use; it's just the+-- same as for instance decls+--+-- NB: Consider this:+-- module Foo where { data R = R { fld :: Int } }+-- module Odd where { import Foo; fld x = x { fld = 3 } }+-- Arguably this should work, because the reference to 'fld' is+-- unambiguous because there is only one field id 'fld' in scope.+-- But currently it's rejected.++lookupRecFieldOcc :: Maybe Name -- Nothing => just look it up as usual+ -- Just tycon => use tycon to disambiguate+ -> SDoc -> RdrName+ -> RnM Name+lookupRecFieldOcc parent doc rdr_name+ | Just tc_name <- parent+ = do { mb_name <- lookupSubBndrOcc True tc_name doc rdr_name+ ; case mb_name of+ Left err -> do { addErr err; return (mkUnboundNameRdr rdr_name) }+ Right n -> return n }++ | otherwise+ -- This use of Global is right as we are looking up a selector which+ -- can only be defined at the top level.+ = lookupGlobalOccRn rdr_name++++-- | Used in export lists to lookup the children.+lookupSubBndrOcc_helper :: Bool -> Bool -> Name -> RdrName+ -> RnM ChildLookupResult+lookupSubBndrOcc_helper must_have_parent warn_if_deprec parent rdr_name+ | isUnboundName parent+ -- Avoid an error cascade+ = return (FoundName NoParent (mkUnboundNameRdr rdr_name))++ | otherwise = do+ gre_env <- getGlobalRdrEnv++ let original_gres = lookupGlobalRdrEnv gre_env (rdrNameOcc rdr_name)+ -- Disambiguate the lookup based on the parent information.+ -- The remaining GREs are things that we *could* export here, note that+ -- this includes things which have `NoParent`. Those are sorted in+ -- `checkPatSynParent`.+ traceRn "parent" (ppr parent)+ traceRn "lookupExportChild original_gres:" (ppr original_gres)+ traceRn "lookupExportChild picked_gres:" (ppr $ picked_gres original_gres)+ case picked_gres original_gres of+ NoOccurrence ->+ noMatchingParentErr original_gres+ UniqueOccurrence g ->+ if must_have_parent then noMatchingParentErr original_gres+ else checkFld g+ DisambiguatedOccurrence g ->+ checkFld g+ AmbiguousOccurrence gres ->+ mkNameClashErr gres+ where+ -- Convert into FieldLabel if necessary+ checkFld :: GlobalRdrElt -> RnM ChildLookupResult+ checkFld g@GRE{gre_name, gre_par} = do+ addUsedGRE warn_if_deprec g+ return $ case gre_par of+ FldParent _ mfs ->+ FoundFL (fldParentToFieldLabel gre_name mfs)+ _ -> FoundName gre_par gre_name++ fldParentToFieldLabel :: Name -> Maybe FastString -> FieldLabel+ fldParentToFieldLabel name mfs =+ case mfs of+ Nothing ->+ let fs = occNameFS (nameOccName name)+ in FieldLabel fs False name+ Just fs -> FieldLabel fs True name++ -- Called when we find no matching GREs after disambiguation but+ -- there are three situations where this happens.+ -- 1. There were none to begin with.+ -- 2. None of the matching ones were the parent but+ -- a. They were from an overloaded record field so we can report+ -- a better error+ -- b. The original lookup was actually ambiguous.+ -- For example, the case where overloading is off and two+ -- record fields are in scope from different record+ -- constructors, neither of which is the parent.+ noMatchingParentErr :: [GlobalRdrElt] -> RnM ChildLookupResult+ noMatchingParentErr original_gres = do+ overload_ok <- xoptM LangExt.DuplicateRecordFields+ case original_gres of+ [] -> return NameNotFound+ [g] -> return $ IncorrectParent parent+ (gre_name g) (ppr $ gre_name g)+ [p | Just p <- [getParent g]]+ gss@(g:_:_) ->+ if all isRecFldGRE gss && overload_ok+ then return $+ IncorrectParent parent+ (gre_name g)+ (ppr $ expectJust "noMatchingParentErr" (greLabel g))+ [p | x <- gss, Just p <- [getParent x]]+ else mkNameClashErr gss++ mkNameClashErr :: [GlobalRdrElt] -> RnM ChildLookupResult+ mkNameClashErr gres = do+ addNameClashErrRn rdr_name gres+ return (FoundName (gre_par (head gres)) (gre_name (head gres)))++ getParent :: GlobalRdrElt -> Maybe Name+ getParent (GRE { gre_par = p } ) =+ case p of+ ParentIs cur_parent -> Just cur_parent+ FldParent { par_is = cur_parent } -> Just cur_parent+ NoParent -> Nothing++ picked_gres :: [GlobalRdrElt] -> DisambigInfo+ picked_gres gres+ | isUnqual rdr_name+ = mconcat (map right_parent gres)+ | otherwise+ = mconcat (map right_parent (pickGREs rdr_name gres))+++ right_parent :: GlobalRdrElt -> DisambigInfo+ right_parent p+ | Just cur_parent <- getParent p+ = if parent == cur_parent+ then DisambiguatedOccurrence p+ else NoOccurrence+ | otherwise+ = UniqueOccurrence p+++-- This domain specific datatype is used to record why we decided it was+-- possible that a GRE could be exported with a parent.+data DisambigInfo+ = NoOccurrence+ -- The GRE could never be exported. It has the wrong parent.+ | UniqueOccurrence GlobalRdrElt+ -- The GRE has no parent. It could be a pattern synonym.+ | DisambiguatedOccurrence GlobalRdrElt+ -- The parent of the GRE is the correct parent+ | AmbiguousOccurrence [GlobalRdrElt]+ -- For example, two normal identifiers with the same name are in+ -- scope. They will both be resolved to "UniqueOccurrence" and the+ -- monoid will combine them to this failing case.++instance Outputable DisambigInfo where+ ppr NoOccurrence = text "NoOccurence"+ ppr (UniqueOccurrence gre) = text "UniqueOccurrence:" <+> ppr gre+ ppr (DisambiguatedOccurrence gre) = text "DiambiguatedOccurrence:" <+> ppr gre+ ppr (AmbiguousOccurrence gres) = text "Ambiguous:" <+> ppr gres++instance Semi.Semigroup DisambigInfo where+ -- This is the key line: We prefer disambiguated occurrences to other+ -- names.+ _ <> DisambiguatedOccurrence g' = DisambiguatedOccurrence g'+ DisambiguatedOccurrence g' <> _ = DisambiguatedOccurrence g'++ NoOccurrence <> m = m+ m <> NoOccurrence = m+ UniqueOccurrence g <> UniqueOccurrence g'+ = AmbiguousOccurrence [g, g']+ UniqueOccurrence g <> AmbiguousOccurrence gs+ = AmbiguousOccurrence (g:gs)+ AmbiguousOccurrence gs <> UniqueOccurrence g'+ = AmbiguousOccurrence (g':gs)+ AmbiguousOccurrence gs <> AmbiguousOccurrence gs'+ = AmbiguousOccurrence (gs ++ gs')++instance Monoid DisambigInfo where+ mempty = NoOccurrence+ mappend = (Semi.<>)++-- Lookup SubBndrOcc can never be ambiguous+--+-- Records the result of looking up a child.+data ChildLookupResult+ = NameNotFound -- We couldn't find a suitable name+ | IncorrectParent Name -- Parent+ Name -- Name of thing we were looking for+ SDoc -- How to print the name+ [Name] -- List of possible parents+ | FoundName Parent Name -- We resolved to a normal name+ | FoundFL FieldLabel -- We resolved to a FL++-- | Specialised version of msum for RnM ChildLookupResult+combineChildLookupResult :: [RnM ChildLookupResult] -> RnM ChildLookupResult+combineChildLookupResult [] = return NameNotFound+combineChildLookupResult (x:xs) = do+ res <- x+ case res of+ NameNotFound -> combineChildLookupResult xs+ _ -> return res++instance Outputable ChildLookupResult where+ ppr NameNotFound = text "NameNotFound"+ ppr (FoundName p n) = text "Found:" <+> ppr p <+> ppr n+ ppr (FoundFL fls) = text "FoundFL:" <+> ppr fls+ ppr (IncorrectParent p n td ns) = text "IncorrectParent"+ <+> hsep [ppr p, ppr n, td, ppr ns]++lookupSubBndrOcc :: Bool+ -> Name -- Parent+ -> SDoc+ -> RdrName+ -> RnM (Either MsgDoc Name)+-- Find all the things the rdr-name maps to+-- and pick the one with the right parent namep+lookupSubBndrOcc warn_if_deprec the_parent doc rdr_name = do+ res <-+ lookupExactOrOrig rdr_name (FoundName NoParent) $+ -- This happens for built-in classes, see mod052 for example+ lookupSubBndrOcc_helper True warn_if_deprec the_parent rdr_name+ case res of+ NameNotFound -> return (Left (unknownSubordinateErr doc rdr_name))+ FoundName _p n -> return (Right n)+ FoundFL fl -> return (Right (flSelector fl))+ IncorrectParent {} -> return $ Left (unknownSubordinateErr doc rdr_name)+++{-+Note [Family instance binders]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ data family F a+ data instance F T = X1 | X2++The 'data instance' decl has an *occurrence* of F (and T), and *binds*+X1 and X2. (This is unlike a normal data type declaration which would+bind F too.) So we want an AvailTC F [X1,X2].++Now consider a similar pair:+ class C a where+ data G a+ instance C S where+ data G S = Y1 | Y2++The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.++But there is a small complication: in an instance decl, we don't use+qualified names on the LHS; instead we use the class to disambiguate.+Thus:+ module M where+ import Blib( G )+ class C a where+ data G a+ instance C S where+ data G S = Y1 | Y2+Even though there are two G's in scope (M.G and Blib.G), the occurrence+of 'G' in the 'instance C S' decl is unambiguous, because C has only+one associated type called G. This is exactly what happens for methods,+and it is only consistent to do the same thing for types. That's the+role of the function lookupTcdName; the (Maybe Name) give the class of+the encloseing instance decl, if any.++Note [Looking up Exact RdrNames]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Exact RdrNames are generated by Template Haskell. See Note [Binders+in Template Haskell] in Convert.++For data types and classes have Exact system Names in the binding+positions for constructors, TyCons etc. For example+ [d| data T = MkT Int |]+when we splice in and Convert to HsSyn RdrName, we'll get+ data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...+These System names are generated by Convert.thRdrName++But, constructors and the like need External Names, not System Names!+So we do the following++ * In RnEnv.newTopSrcBinder we spot Exact RdrNames that wrap a+ non-External Name, and make an External name for it. This is+ the name that goes in the GlobalRdrEnv++ * When looking up an occurrence of an Exact name, done in+ RnEnv.lookupExactOcc, we find the Name with the right unique in the+ GlobalRdrEnv, and use the one from the envt -- it will be an+ External Name in the case of the data type/constructor above.++ * Exact names are also use for purely local binders generated+ by TH, such as \x_33. x_33+ Both binder and occurrence are Exact RdrNames. The occurrence+ gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and+ misses, because lookupLocalRdrEnv always returns Nothing for+ an Exact Name. Now we fall through to lookupExactOcc, which+ will find the Name is not in the GlobalRdrEnv, so we just use+ the Exact supplied Name.++Note [Splicing Exact names]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider the splice $(do { x <- newName "x"; return (VarE x) })+This will generate a (HsExpr RdrName) term that mentions the+Exact RdrName "x_56" (or whatever), but does not bind it. So+when looking such Exact names we want to check that it's in scope,+otherwise the type checker will get confused. To do this we need to+keep track of all the Names in scope, and the LocalRdrEnv does just that;+we consult it with RdrName.inLocalRdrEnvScope.++There is another wrinkle. With TH and -XDataKinds, consider+ $( [d| data Nat = Zero+ data T = MkT (Proxy 'Zero) |] )+After splicing, but before renaming we get this:+ data Nat_77{tc} = Zero_78{d}+ data T_79{tc} = MkT_80{d} (Proxy 'Zero_78{tc}) |] )+The occurrence of 'Zero in the data type for T has the right unique,+but it has a TcClsName name-space in its OccName. (This is set by+the ctxt_ns argument of Convert.thRdrName.) When we check that is+in scope in the GlobalRdrEnv, we need to look up the DataName namespace+too. (An alternative would be to make the GlobalRdrEnv also have+a Name -> GRE mapping.)++Note [Template Haskell ambiguity]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The GlobalRdrEnv invariant says that if+ occ -> [gre1, ..., gren]+then the gres have distinct Names (INVARIANT 1 of GlobalRdrEnv).+This is guaranteed by extendGlobalRdrEnvRn (the dups check in add_gre).++So how can we get multiple gres in lookupExactOcc_maybe? Because in+TH we might use the same TH NameU in two different name spaces.+eg (Trac #7241):+ $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])+Here we generate a type constructor and data constructor with the same+unique, but different name spaces.++It'd be nicer to rule this out in extendGlobalRdrEnvRn, but that would+mean looking up the OccName in every name-space, just in case, and that+seems a bit brutal. So it's just done here on lookup. But we might+need to revisit that choice.++Note [Usage for sub-bndrs]+~~~~~~~~~~~~~~~~~~~~~~~~~~+If you have this+ import qualified M( C( f ) )+ instance M.C T where+ f x = x+then is the qualified import M.f used? Obviously yes.+But the RdrName used in the instance decl is unqualified. In effect,+we fill in the qualification by looking for f's whose class is M.C+But when adding to the UsedRdrNames we must make that qualification+explicit (saying "used M.f"), otherwise we get "Redundant import of M.f".++So we make up a suitable (fake) RdrName. But be careful+ import qualified M+ import M( C(f) )+ instance C T where+ f x = x+Here we want to record a use of 'f', not of 'M.f', otherwise+we'll miss the fact that the qualified import is redundant.++--------------------------------------------------+-- Occurrences+--------------------------------------------------+-}+++lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)+lookupLocatedOccRn = wrapLocM lookupOccRn++lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)+-- Just look in the local environment+lookupLocalOccRn_maybe rdr_name+ = do { local_env <- getLocalRdrEnv+ ; return (lookupLocalRdrEnv local_env rdr_name) }++lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))+-- Just look in the local environment+lookupLocalOccThLvl_maybe name+ = do { lcl_env <- getLclEnv+ ; return (lookupNameEnv (tcl_th_bndrs lcl_env) name) }++-- lookupOccRn looks up an occurrence of a RdrName+lookupOccRn :: RdrName -> RnM Name+lookupOccRn rdr_name+ = do { mb_name <- lookupOccRn_maybe rdr_name+ ; case mb_name of+ Just name -> return name+ Nothing -> reportUnboundName rdr_name }++-- Only used in one place, to rename pattern synonym binders.+-- See Note [Renaming pattern synonym variables] in RnBinds+lookupLocalOccRn :: RdrName -> RnM Name+lookupLocalOccRn rdr_name+ = do { mb_name <- lookupLocalOccRn_maybe rdr_name+ ; case mb_name of+ Just name -> return name+ Nothing -> unboundName WL_LocalOnly rdr_name }++lookupKindOccRn :: RdrName -> RnM Name+-- Looking up a name occurring in a kind+lookupKindOccRn rdr_name+ | isVarOcc (rdrNameOcc rdr_name) -- See Note [Promoted variables in types]+ = badVarInType rdr_name+ | otherwise+ = do { typeintype <- xoptM LangExt.TypeInType+ ; if | typeintype -> lookupTypeOccRn rdr_name+ -- With -XNoTypeInType, treat any usage of * in kinds as in scope+ -- this is a dirty hack, but then again so was the old * kind.+ | isStar rdr_name -> return starKindTyConName+ | isUniStar rdr_name -> return unicodeStarKindTyConName+ | otherwise -> lookupOccRn rdr_name }++-- lookupPromotedOccRn looks up an optionally promoted RdrName.+lookupTypeOccRn :: RdrName -> RnM Name+-- see Note [Demotion]+lookupTypeOccRn rdr_name+ | isVarOcc (rdrNameOcc rdr_name) -- See Note [Promoted variables in types]+ = badVarInType rdr_name+ | otherwise+ = do { mb_name <- lookupOccRn_maybe rdr_name+ ; case mb_name of {+ Just name -> return name ;+ Nothing -> do { dflags <- getDynFlags+ ; lookup_demoted rdr_name dflags } } }++lookup_demoted :: RdrName -> DynFlags -> RnM Name+lookup_demoted rdr_name dflags+ | Just demoted_rdr <- demoteRdrName rdr_name+ -- Maybe it's the name of a *data* constructor+ = do { data_kinds <- xoptM LangExt.DataKinds+ ; if data_kinds+ then do { mb_demoted_name <- lookupOccRn_maybe demoted_rdr+ ; case mb_demoted_name of+ Nothing -> unboundNameX WL_Any rdr_name star_info+ Just demoted_name ->+ do { whenWOptM Opt_WarnUntickedPromotedConstructors $+ addWarn+ (Reason Opt_WarnUntickedPromotedConstructors)+ (untickedPromConstrWarn demoted_name)+ ; return demoted_name } }+ else do { -- We need to check if a data constructor of this name is+ -- in scope to give good error messages. However, we do+ -- not want to give an additional error if the data+ -- constructor happens to be out of scope! See #13947.+ mb_demoted_name <- discardErrs $+ lookupOccRn_maybe demoted_rdr+ ; let suggestion | isJust mb_demoted_name = suggest_dk+ | otherwise = star_info+ ; unboundNameX WL_Any rdr_name suggestion } }++ | otherwise+ = reportUnboundName rdr_name++ where+ suggest_dk = text "A data constructor of that name is in scope; did you mean DataKinds?"+ untickedPromConstrWarn name =+ text "Unticked promoted constructor" <> colon <+> quotes (ppr name) <> dot+ $$+ hsep [ text "Use"+ , quotes (char '\'' <> ppr name)+ , text "instead of"+ , quotes (ppr name) <> dot ]++ star_info+ | isStar rdr_name || isUniStar rdr_name+ = if xopt LangExt.TypeInType dflags+ then text "NB: With TypeInType, you must import" <+>+ ppr rdr_name <+> text "from Data.Kind"+ else empty++ | otherwise+ = empty+++badVarInType :: RdrName -> RnM Name+badVarInType rdr_name+ = do { addErr (text "Illegal promoted term variable in a type:"+ <+> ppr rdr_name)+ ; return (mkUnboundNameRdr rdr_name) }++{- Note [Promoted variables in types]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this (Trac #12686):+ x = True+ data Bad = Bad 'x++The parser treats the quote in 'x as saying "use the term+namespace", so we'll get (Bad x{v}), with 'x' in the+VarName namespace. If we don't test for this, the renamer+will happily rename it to the x bound at top level, and then+the typecheck falls over because it doesn't have 'x' in scope+when kind-checking.++Note [Demotion]+~~~~~~~~~~~~~~~+When the user writes:+ data Nat = Zero | Succ Nat+ foo :: f Zero -> Int++'Zero' in the type signature of 'foo' is parsed as:+ HsTyVar ("Zero", TcClsName)++When the renamer hits this occurrence of 'Zero' it's going to realise+that it's not in scope. But because it is renaming a type, it knows+that 'Zero' might be a promoted data constructor, so it will demote+its namespace to DataName and do a second lookup.++The final result (after the renamer) will be:+ HsTyVar ("Zero", DataName)+-}++lookupOccRnX_maybe :: (RdrName -> RnM (Maybe r)) -> (Name -> r) -> RdrName+ -> RnM (Maybe r)+lookupOccRnX_maybe globalLookup wrapper rdr_name+ = runMaybeT . msum . map MaybeT $+ [ fmap wrapper <$> lookupLocalOccRn_maybe rdr_name+ , globalLookup rdr_name ]++lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)+lookupOccRn_maybe = lookupOccRnX_maybe lookupGlobalOccRn_maybe id++lookupOccRn_overloaded :: Bool -> RdrName+ -> RnM (Maybe (Either Name [Name]))+lookupOccRn_overloaded overload_ok+ = lookupOccRnX_maybe global_lookup Left+ where+ global_lookup :: RdrName -> RnM (Maybe (Either Name [Name]))+ global_lookup n =+ runMaybeT . msum . map MaybeT $+ [ lookupGlobalOccRn_overloaded overload_ok n+ , fmap Left . listToMaybe <$> lookupQualifiedNameGHCi n ]++++lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)+-- Looks up a RdrName occurrence in the top-level+-- environment, including using lookupQualifiedNameGHCi+-- for the GHCi case+-- No filter function; does not report an error on failure+-- Uses addUsedRdrName to record use and deprecations+lookupGlobalOccRn_maybe rdr_name =+ lookupExactOrOrig rdr_name Just $+ runMaybeT . msum . map MaybeT $+ [ fmap gre_name <$> lookupGreRn_maybe rdr_name+ , listToMaybe <$> lookupQualifiedNameGHCi rdr_name ]+ -- This test is not expensive,+ -- and only happens for failed lookups++lookupGlobalOccRn :: RdrName -> RnM Name+-- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global+-- environment. Adds an error message if the RdrName is not in scope.+-- You usually want to use "lookupOccRn" which also looks in the local+-- environment.+lookupGlobalOccRn rdr_name+ = do { mb_name <- lookupGlobalOccRn_maybe rdr_name+ ; case mb_name of+ Just n -> return n+ Nothing -> do { traceRn "lookupGlobalOccRn" (ppr rdr_name)+ ; unboundName WL_Global rdr_name } }++lookupInfoOccRn :: RdrName -> RnM [Name]+-- lookupInfoOccRn is intended for use in GHCi's ":info" command+-- It finds all the GREs that RdrName could mean, not complaining+-- about ambiguity, but rather returning them all+-- C.f. Trac #9881+lookupInfoOccRn rdr_name =+ lookupExactOrOrig rdr_name (:[]) $+ do { rdr_env <- getGlobalRdrEnv+ ; let ns = map gre_name (lookupGRE_RdrName rdr_name rdr_env)+ ; qual_ns <- lookupQualifiedNameGHCi rdr_name+ ; return (ns ++ (qual_ns `minusList` ns)) }++-- | Like 'lookupOccRn_maybe', but with a more informative result if+-- the 'RdrName' happens to be a record selector:+--+-- * Nothing -> name not in scope (no error reported)+-- * Just (Left x) -> name uniquely refers to x,+-- or there is a name clash (reported)+-- * Just (Right xs) -> name refers to one or more record selectors;+-- if overload_ok was False, this list will be+-- a singleton.++lookupGlobalOccRn_overloaded :: Bool -> RdrName+ -> RnM (Maybe (Either Name [Name]))+lookupGlobalOccRn_overloaded overload_ok rdr_name =+ lookupExactOrOrig rdr_name (Just . Left) $+ do { res <- lookupGreRn_helper rdr_name+ ; case res of+ GreNotFound -> return Nothing+ OneNameMatch gre -> do+ let wrapper = if isRecFldGRE gre then Right . (:[]) else Left+ return $ Just (wrapper (gre_name gre))+ MultipleNames gres | all isRecFldGRE gres && overload_ok ->+ -- Don't record usage for ambiguous selectors+ -- until we know which is meant+ return $ Just (Right (map gre_name gres))+ MultipleNames gres -> do+ addNameClashErrRn rdr_name gres+ return (Just (Left (gre_name (head gres)))) }+++--------------------------------------------------+-- Lookup in the Global RdrEnv of the module+--------------------------------------------------++data GreLookupResult = GreNotFound+ | OneNameMatch GlobalRdrElt+ | MultipleNames [GlobalRdrElt]++lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)+-- Look up the RdrName in the GlobalRdrEnv+-- Exactly one binding: records it as "used", return (Just gre)+-- No bindings: return Nothing+-- Many bindings: report "ambiguous", return an arbitrary (Just gre)+-- Uses addUsedRdrName to record use and deprecations+lookupGreRn_maybe rdr_name+ = do+ res <- lookupGreRn_helper rdr_name+ case res of+ OneNameMatch gre -> return $ Just gre+ MultipleNames gres -> do+ traceRn "lookupGreRn_maybe:NameClash" (ppr gres)+ addNameClashErrRn rdr_name gres+ return $ Just (head gres)+ GreNotFound -> return Nothing++{-++Note [ Unbound vs Ambiguous Names ]++lookupGreRn_maybe deals with failures in two different ways. If a name+is unbound then we return a `Nothing` but if the name is ambiguous+then we raise an error and return a dummy name.++The reason for this is that when we call `lookupGreRn_maybe` we are+speculatively looking for whatever we are looking up. If we don't find it,+then we might have been looking for the wrong thing and can keep trying.+On the other hand, if we find a clash then there is no way to recover as+we found the thing we were looking for but can no longer resolve which+the correct one is.++One example of this is in `lookupTypeOccRn` which first looks in the type+constructor namespace before looking in the data constructor namespace to+deal with `DataKinds`.++There is however, as always, one exception to this scheme. If we find+an ambiguous occurence of a record selector and DuplicateRecordFields+is enabled then we defer the selection until the typechecker.++-}+++++-- Internal Function+lookupGreRn_helper :: RdrName -> RnM GreLookupResult+lookupGreRn_helper rdr_name+ = do { env <- getGlobalRdrEnv+ ; case lookupGRE_RdrName rdr_name env of+ [] -> return GreNotFound+ [gre] -> do { addUsedGRE True gre+ ; return (OneNameMatch gre) }+ gres -> return (MultipleNames gres) }++lookupGreAvailRn :: RdrName -> RnM (Name, AvailInfo)+-- Used in export lists+-- If not found or ambiguous, add error message, and fake with UnboundName+-- Uses addUsedRdrName to record use and deprecations+lookupGreAvailRn rdr_name+ = do+ mb_gre <- lookupGreRn_helper rdr_name+ case mb_gre of+ GreNotFound ->+ do+ traceRn "lookupGreAvailRn" (ppr rdr_name)+ name <- unboundName WL_Global rdr_name+ return (name, avail name)+ MultipleNames gres ->+ do+ addNameClashErrRn rdr_name gres+ let unbound_name = mkUnboundNameRdr rdr_name+ return (unbound_name, avail unbound_name)+ -- Returning an unbound name here prevents an error+ -- cascade+ OneNameMatch gre ->+ return (gre_name gre, availFromGRE gre)+++{-+*********************************************************+* *+ Deprecations+* *+*********************************************************++Note [Handling of deprecations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+* We report deprecations at each *occurrence* of the deprecated thing+ (see Trac #5867)++* We do not report deprecations for locally-defined names. For a+ start, we may be exporting a deprecated thing. Also we may use a+ deprecated thing in the defn of another deprecated things. We may+ even use a deprecated thing in the defn of a non-deprecated thing,+ when changing a module's interface.++* addUsedGREs: we do not report deprecations for sub-binders:+ - the ".." completion for records+ - the ".." in an export item 'T(..)'+ - the things exported by a module export 'module M'+-}++addUsedDataCons :: GlobalRdrEnv -> TyCon -> RnM ()+-- Remember use of in-scope data constructors (Trac #7969)+addUsedDataCons rdr_env tycon+ = addUsedGREs [ gre+ | dc <- tyConDataCons tycon+ , Just gre <- [lookupGRE_Name rdr_env (dataConName dc)] ]++addUsedGRE :: Bool -> GlobalRdrElt -> RnM ()+-- Called for both local and imported things+-- Add usage *and* warn if deprecated+addUsedGRE warn_if_deprec gre+ = do { when warn_if_deprec (warnIfDeprecated gre)+ ; unless (isLocalGRE gre) $+ do { env <- getGblEnv+ ; traceRn "addUsedGRE" (ppr gre)+ ; updMutVar (tcg_used_gres env) (gre :) } }++addUsedGREs :: [GlobalRdrElt] -> RnM ()+-- Record uses of any *imported* GREs+-- Used for recording used sub-bndrs+-- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]+addUsedGREs gres+ | null imp_gres = return ()+ | otherwise = do { env <- getGblEnv+ ; traceRn "addUsedGREs" (ppr imp_gres)+ ; updMutVar (tcg_used_gres env) (imp_gres ++) }+ where+ imp_gres = filterOut isLocalGRE gres++warnIfDeprecated :: GlobalRdrElt -> RnM ()+warnIfDeprecated gre@(GRE { gre_name = name, gre_imp = iss })+ | (imp_spec : _) <- iss+ = do { dflags <- getDynFlags+ ; this_mod <- getModule+ ; when (wopt Opt_WarnWarningsDeprecations dflags &&+ not (nameIsLocalOrFrom this_mod name)) $+ -- See Note [Handling of deprecations]+ do { iface <- loadInterfaceForName doc name+ ; case lookupImpDeprec iface gre of+ Just txt -> addWarn (Reason Opt_WarnWarningsDeprecations)+ (mk_msg imp_spec txt)+ Nothing -> return () } }+ | otherwise+ = return ()+ where+ occ = greOccName gre+ name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name+ doc = text "The name" <+> quotes (ppr occ) <+> ptext (sLit "is mentioned explicitly")++ mk_msg imp_spec txt+ = sep [ sep [ text "In the use of"+ <+> pprNonVarNameSpace (occNameSpace occ)+ <+> quotes (ppr occ)+ , parens imp_msg <> colon ]+ , pprWarningTxtForMsg txt ]+ where+ imp_mod = importSpecModule imp_spec+ imp_msg = text "imported from" <+> ppr imp_mod <> extra+ extra | imp_mod == moduleName name_mod = Outputable.empty+ | otherwise = text ", but defined in" <+> ppr name_mod++lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt+lookupImpDeprec iface gre+ = mi_warn_fn iface (greOccName gre) `mplus` -- Bleat if the thing,+ case gre_par gre of -- or its parent, is warn'd+ ParentIs p -> mi_warn_fn iface (nameOccName p)+ FldParent { par_is = p } -> mi_warn_fn iface (nameOccName p)+ NoParent -> Nothing++{-+Note [Used names with interface not loaded]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's (just) possible to find a used+Name whose interface hasn't been loaded:++a) It might be a WiredInName; in that case we may not load+ its interface (although we could).++b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger+ These are seen as "used" by the renamer (if -XRebindableSyntax)+ is on), but the typechecker may discard their uses+ if in fact the in-scope fromRational is GHC.Read.fromRational,+ (see tcPat.tcOverloadedLit), and the typechecker sees that the type+ is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).+ In that obscure case it won't force the interface in.++In both cases we simply don't permit deprecations;+this is, after all, wired-in stuff.+++*********************************************************+* *+ GHCi support+* *+*********************************************************++A qualified name on the command line can refer to any module at+all: we try to load the interface if we don't already have it, just+as if there was an "import qualified M" declaration for every+module.++For example, writing `Data.List.sort` will load the interface file for+`Data.List` as if the user had written `import qualified Data.List`.++If we fail we just return Nothing, rather than bleating+about "attempting to use module ‘D’ (./D.hs) which is not loaded"+which is what loadSrcInterface does.++It is enabled by default and disabled by the flag+`-fno-implicit-import-qualified`.++Note [Safe Haskell and GHCi]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We DON'T do this Safe Haskell as we need to check imports. We can+and should instead check the qualified import but at the moment+this requires some refactoring so leave as a TODO+-}++++lookupQualifiedNameGHCi :: RdrName -> RnM [Name]+lookupQualifiedNameGHCi rdr_name+ = -- We want to behave as we would for a source file import here,+ -- and respect hiddenness of modules/packages, hence loadSrcInterface.+ do { dflags <- getDynFlags+ ; is_ghci <- getIsGHCi+ ; go_for_it dflags is_ghci }++ where+ go_for_it dflags is_ghci+ | Just (mod,occ) <- isQual_maybe rdr_name+ , is_ghci+ , gopt Opt_ImplicitImportQualified dflags -- Enables this GHCi behaviour+ , not (safeDirectImpsReq dflags) -- See Note [Safe Haskell and GHCi]+ = do { res <- loadSrcInterface_maybe doc mod False Nothing+ ; case res of+ Succeeded iface+ -> return [ name+ | avail <- mi_exports iface+ , name <- availNames avail+ , nameOccName name == occ ]++ _ -> -- Either we couldn't load the interface, or+ -- we could but we didn't find the name in it+ do { traceRn "lookupQualifiedNameGHCi" (ppr rdr_name)+ ; return [] } }++ | otherwise+ = do { traceRn "lookupQualifiedNameGHCi: off" (ppr rdr_name)+ ; return [] }++ doc = text "Need to find" <+> ppr rdr_name++{-+Note [Looking up signature names]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+lookupSigOccRn is used for type signatures and pragmas+Is this valid?+ module A+ import M( f )+ f :: Int -> Int+ f x = x+It's clear that the 'f' in the signature must refer to A.f+The Haskell98 report does not stipulate this, but it will!+So we must treat the 'f' in the signature in the same way+as the binding occurrence of 'f', using lookupBndrRn++However, consider this case:+ import M( f )+ f :: Int -> Int+ g x = x+We don't want to say 'f' is out of scope; instead, we want to+return the imported 'f', so that later on the reanamer will+correctly report "misplaced type sig".++Note [Signatures for top level things]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+data HsSigCtxt = ... | TopSigCtxt NameSet | ....++* The NameSet says what is bound in this group of bindings.+ We can't use isLocalGRE from the GlobalRdrEnv, because of this:+ f x = x+ $( ...some TH splice... )+ f :: Int -> Int+ When we encounter the signature for 'f', the binding for 'f'+ will be in the GlobalRdrEnv, and will be a LocalDef. Yet the+ signature is mis-placed++* For type signatures the NameSet should be the names bound by the+ value bindings; for fixity declarations, the NameSet should also+ include class sigs and record selectors++ infix 3 `f` -- Yes, ok+ f :: C a => a -> a -- No, not ok+ class C a where+ f :: a -> a+-}++data HsSigCtxt+ = TopSigCtxt NameSet -- At top level, binding these names+ -- See Note [Signatures for top level things]+ | LocalBindCtxt NameSet -- In a local binding, binding these names+ | ClsDeclCtxt Name -- Class decl for this class+ | InstDeclCtxt NameSet -- Instance decl whose user-written method+ -- bindings are for these methods+ | HsBootCtxt NameSet -- Top level of a hs-boot file, binding these names+ | RoleAnnotCtxt NameSet -- A role annotation, with the names of all types+ -- in the group++instance Outputable HsSigCtxt where+ ppr (TopSigCtxt ns) = text "TopSigCtxt" <+> ppr ns+ ppr (LocalBindCtxt ns) = text "LocalBindCtxt" <+> ppr ns+ ppr (ClsDeclCtxt n) = text "ClsDeclCtxt" <+> ppr n+ ppr (InstDeclCtxt ns) = text "InstDeclCtxt" <+> ppr ns+ ppr (HsBootCtxt ns) = text "HsBootCtxt" <+> ppr ns+ ppr (RoleAnnotCtxt ns) = text "RoleAnnotCtxt" <+> ppr ns++lookupSigOccRn :: HsSigCtxt+ -> Sig GhcPs+ -> Located RdrName -> RnM (Located Name)+lookupSigOccRn ctxt sig = lookupSigCtxtOccRn ctxt (hsSigDoc sig)++-- | Lookup a name in relation to the names in a 'HsSigCtxt'+lookupSigCtxtOccRn :: HsSigCtxt+ -> SDoc -- ^ description of thing we're looking up,+ -- like "type family"+ -> Located RdrName -> RnM (Located Name)+lookupSigCtxtOccRn ctxt what+ = wrapLocM $ \ rdr_name ->+ do { mb_name <- lookupBindGroupOcc ctxt what rdr_name+ ; case mb_name of+ Left err -> do { addErr err; return (mkUnboundNameRdr rdr_name) }+ Right name -> return name }++lookupBindGroupOcc :: HsSigCtxt+ -> SDoc+ -> RdrName -> RnM (Either MsgDoc Name)+-- Looks up the RdrName, expecting it to resolve to one of the+-- bound names passed in. If not, return an appropriate error message+--+-- See Note [Looking up signature names]+lookupBindGroupOcc ctxt what rdr_name+ | Just n <- isExact_maybe rdr_name+ = lookupExactOcc_either n -- allow for the possibility of missing Exacts;+ -- see Note [dataTcOccs and Exact Names]+ -- Maybe we should check the side conditions+ -- but it's a pain, and Exact things only show+ -- up when you know what you are doing++ | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name+ = do { n' <- lookupOrig rdr_mod rdr_occ+ ; return (Right n') }++ | otherwise+ = case ctxt of+ HsBootCtxt ns -> lookup_top (`elemNameSet` ns)+ TopSigCtxt ns -> lookup_top (`elemNameSet` ns)+ RoleAnnotCtxt ns -> lookup_top (`elemNameSet` ns)+ LocalBindCtxt ns -> lookup_group ns+ ClsDeclCtxt cls -> lookup_cls_op cls+ InstDeclCtxt ns -> lookup_top (`elemNameSet` ns)+ where+ lookup_cls_op cls+ = lookupSubBndrOcc True cls doc rdr_name+ where+ doc = text "method of class" <+> quotes (ppr cls)++ lookup_top keep_me+ = do { env <- getGlobalRdrEnv+ ; let all_gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)+ ; case filter (keep_me . gre_name) all_gres of+ [] | null all_gres -> bale_out_with Outputable.empty+ | otherwise -> bale_out_with local_msg+ (gre:_) -> return (Right (gre_name gre)) }++ lookup_group bound_names -- Look in the local envt (not top level)+ = do { mname <- lookupLocalOccRn_maybe rdr_name+ ; case mname of+ Just n+ | n `elemNameSet` bound_names -> return (Right n)+ | otherwise -> bale_out_with local_msg+ Nothing -> bale_out_with Outputable.empty }++ bale_out_with msg+ = return (Left (sep [ text "The" <+> what+ <+> text "for" <+> quotes (ppr rdr_name)+ , nest 2 $ text "lacks an accompanying binding"]+ $$ nest 2 msg))++ local_msg = parens $ text "The" <+> what <+> ptext (sLit "must be given where")+ <+> quotes (ppr rdr_name) <+> text "is declared"+++---------------+lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [(RdrName, Name)]+-- GHC extension: look up both the tycon and data con or variable.+-- Used for top-level fixity signatures and deprecations.+-- Complain if neither is in scope.+-- See Note [Fixity signature lookup]+lookupLocalTcNames ctxt what rdr_name+ = do { mb_gres <- mapM lookup (dataTcOccs rdr_name)+ ; let (errs, names) = splitEithers mb_gres+ ; when (null names) $ addErr (head errs) -- Bleat about one only+ ; return names }+ where+ lookup rdr = do { name <- lookupBindGroupOcc ctxt what rdr+ ; return (fmap ((,) rdr) name) }++dataTcOccs :: RdrName -> [RdrName]+-- Return both the given name and the same name promoted to the TcClsName+-- namespace. This is useful when we aren't sure which we are looking at.+-- See also Note [dataTcOccs and Exact Names]+dataTcOccs rdr_name+ | isDataOcc occ || isVarOcc occ+ = [rdr_name, rdr_name_tc]+ | otherwise+ = [rdr_name]+ where+ occ = rdrNameOcc rdr_name+ rdr_name_tc = setRdrNameSpace rdr_name tcName++{-+Note [dataTcOccs and Exact Names]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Exact RdrNames can occur in code generated by Template Haskell, and generally+those references are, well, exact. However, the TH `Name` type isn't expressive+enough to always track the correct namespace information, so we sometimes get+the right Unique but wrong namespace. Thus, we still have to do the double-lookup+for Exact RdrNames.++There is also an awkward situation for built-in syntax. Example in GHCi+ :info []+This parses as the Exact RdrName for nilDataCon, but we also want+the list type constructor.++Note that setRdrNameSpace on an Exact name requires the Name to be External,+which it always is for built in syntax.+-}++++{-+************************************************************************+* *+ Rebindable names+ Dealing with rebindable syntax is driven by the+ Opt_RebindableSyntax dynamic flag.++ In "deriving" code we don't want to use rebindable syntax+ so we switch off the flag locally++* *+************************************************************************++Haskell 98 says that when you say "3" you get the "fromInteger" from the+Standard Prelude, regardless of what is in scope. However, to experiment+with having a language that is less coupled to the standard prelude, we're+trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"+happens to be in scope. Then you can+ import Prelude ()+ import MyPrelude as Prelude+to get the desired effect.++At the moment this just happens for+ * fromInteger, fromRational on literals (in expressions and patterns)+ * negate (in expressions)+ * minus (arising from n+k patterns)+ * "do" notation++We store the relevant Name in the HsSyn tree, in+ * HsIntegral/HsFractional/HsIsString+ * NegApp+ * NPlusKPat+ * HsDo+respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,+fromRationalName etc), but the renamer changes this to the appropriate user+name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.++We treat the original (standard) names as free-vars too, because the type checker+checks the type of the user thing against the type of the standard thing.+-}++lookupIfThenElse :: RnM (Maybe (SyntaxExpr GhcRn), FreeVars)+-- Different to lookupSyntaxName because in the non-rebindable+-- case we desugar directly rather than calling an existing function+-- Hence the (Maybe (SyntaxExpr GhcRn)) return type+lookupIfThenElse+ = do { rebindable_on <- xoptM LangExt.RebindableSyntax+ ; if not rebindable_on+ then return (Nothing, emptyFVs)+ else do { ite <- lookupOccRn (mkVarUnqual (fsLit "ifThenElse"))+ ; return ( Just (mkRnSyntaxExpr ite)+ , unitFV ite ) } }++lookupSyntaxName' :: Name -- ^ The standard name+ -> RnM Name -- ^ Possibly a non-standard name+lookupSyntaxName' std_name+ = do { rebindable_on <- xoptM LangExt.RebindableSyntax+ ; if not rebindable_on then+ return std_name+ else+ -- Get the similarly named thing from the local environment+ lookupOccRn (mkRdrUnqual (nameOccName std_name)) }++lookupSyntaxName :: Name -- The standard name+ -> RnM (SyntaxExpr GhcRn, FreeVars) -- Possibly a non-standard+ -- name+lookupSyntaxName std_name+ = do { rebindable_on <- xoptM LangExt.RebindableSyntax+ ; if not rebindable_on then+ return (mkRnSyntaxExpr std_name, emptyFVs)+ else+ -- Get the similarly named thing from the local environment+ do { usr_name <- lookupOccRn (mkRdrUnqual (nameOccName std_name))+ ; return (mkRnSyntaxExpr usr_name, unitFV usr_name) } }++lookupSyntaxNames :: [Name] -- Standard names+ -> RnM ([HsExpr GhcRn], FreeVars) -- See comments with HsExpr.ReboundNames+ -- this works with CmdTop, which wants HsExprs, not SyntaxExprs+lookupSyntaxNames std_names+ = do { rebindable_on <- xoptM LangExt.RebindableSyntax+ ; if not rebindable_on then+ return (map (HsVar . noLoc) std_names, emptyFVs)+ else+ do { usr_names <- mapM (lookupOccRn . mkRdrUnqual . nameOccName) std_names+ ; return (map (HsVar . noLoc) usr_names, mkFVs usr_names) } }++-- Error messages+++opDeclErr :: RdrName -> SDoc+opDeclErr n+ = hang (text "Illegal declaration of a type or class operator" <+> quotes (ppr n))+ 2 (text "Use TypeOperators to declare operators in type and declarations")++badOrigBinding :: RdrName -> SDoc+badOrigBinding name+ | Just _ <- isBuiltInOcc_maybe occ+ = text "Illegal binding of built-in syntax:" <+> ppr occ+ -- Use an OccName here because we don't want to print Prelude.(,)+ | otherwise+ = text "Cannot redefine a Name retrieved by a Template Haskell quote:"+ <+> ppr name+ -- This can happen when one tries to use a Template Haskell splice to+ -- define a top-level identifier with an already existing name, e.g.,+ --+ -- $(pure [ValD (VarP 'succ) (NormalB (ConE 'True)) []])+ --+ -- (See Trac #13968.)+ where+ occ = rdrNameOcc name
rename/RnExpr.hs view
@@ -13,6 +13,7 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE MultiWayIf #-}+{-# LANGUAGE TypeFamilies #-} module RnExpr ( rnLExpr, rnExpr, rnStmts@@ -20,12 +21,20 @@ #include "HsVersions.h" +import GhcPrelude+ import RnBinds ( rnLocalBindsAndThen, rnLocalValBindsLHS, rnLocalValBindsRHS, rnMatchGroup, rnGRHS, makeMiniFixityEnv) import HsSyn import TcRnMonad import Module ( getModule ) import RnEnv+import RnFixity+import RnUtils ( HsDocContext(..), bindLocalNamesFV, checkDupNames+ , bindLocalNames+ , mapMaybeFvRn, mapFvRn+ , warnUnusedLocalBinds )+import RnUnbound ( reportUnboundName ) import RnSplice ( rnBracket, rnSpliceExpr, checkThLocalName ) import RnTypes import RnPat@@ -50,6 +59,7 @@ import Data.Ord import Data.Array+import qualified Data.List.NonEmpty as NE {- ************************************************************************@@ -59,7 +69,7 @@ ************************************************************************ -} -rnExprs :: [LHsExpr RdrName] -> RnM ([LHsExpr Name], FreeVars)+rnExprs :: [LHsExpr GhcPs] -> RnM ([LHsExpr GhcRn], FreeVars) rnExprs ls = rnExprs' ls emptyUniqSet where rnExprs' [] acc = return ([], acc)@@ -73,12 +83,12 @@ -- Variables. We look up the variable and return the resulting name. -rnLExpr :: LHsExpr RdrName -> RnM (LHsExpr Name, FreeVars)+rnLExpr :: LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars) rnLExpr = wrapLocFstM rnExpr -rnExpr :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars)+rnExpr :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars) -finishHsVar :: Located Name -> RnM (HsExpr Name, FreeVars)+finishHsVar :: Located Name -> RnM (HsExpr GhcRn, FreeVars) -- Separated from rnExpr because it's also used -- when renaming infix expressions finishHsVar (L l name)@@ -87,7 +97,7 @@ checkThLocalName name ; return (HsVar (L l name), unitFV name) } -rnUnboundVar :: RdrName -> RnM (HsExpr Name, FreeVars)+rnUnboundVar :: RdrName -> RnM (HsExpr GhcRn, FreeVars) rnUnboundVar v = do { if isUnqual v then -- Treat this as a "hole"@@ -115,12 +125,12 @@ | otherwise -> finishHsVar (L l name) ;- Just (Right [f@(FieldOcc (L _ fn) s)]) ->- return (HsRecFld (ambiguousFieldOcc (FieldOcc (L l fn) s))- , unitFV (selectorFieldOcc f)) ;- Just (Right fs@(_:_:_)) -> return (HsRecFld (Ambiguous (L l v)- PlaceHolder)- , mkFVs (map selectorFieldOcc fs));+ Just (Right [s]) ->+ return ( HsRecFld (ambiguousFieldOcc (FieldOcc (L l v) s))+ , unitFV s) ;+ Just (Right fs@(_:_:_)) ->+ return ( HsRecFld (Ambiguous (L l v) PlaceHolder)+ , mkFVs fs); Just (Right []) -> panic "runExpr/HsVar" } } rnExpr (HsIPVar v)@@ -139,15 +149,18 @@ rnExpr (HsOverLit (mkHsIsString src s placeHolderType)) else do { ; rnLit lit- ; return (HsLit lit, emptyFVs) } }+ ; return (HsLit (convertLit lit), emptyFVs) } } rnExpr (HsLit lit) = do { rnLit lit- ; return (HsLit lit, emptyFVs) }+ ; return (HsLit (convertLit lit), emptyFVs) } rnExpr (HsOverLit lit)- = do { (lit', fvs) <- rnOverLit lit- ; return (HsOverLit lit', fvs) }+ = do { ((lit', mb_neg), fvs) <- rnOverLit lit -- See Note [Negative zero]+ ; case mb_neg of+ Nothing -> return (HsOverLit lit', fvs)+ Just neg -> return ( HsApp (noLoc neg) (noLoc (HsOverLit lit'))+ , fvs ) } rnExpr (HsApp fun arg) = do { (fun',fvFun) <- rnLExpr fun@@ -358,12 +371,22 @@ * * ************************************************************************ -For the static form we check that the free variables are all top-level-value bindings. This is done by checking that the name is external or-wired-in. See the Notes about the NameSorts in Name.hs.+For the static form we check that it is not used in splices.+We also collect the free variables of the term which come from+this module. See Note [Grand plan for static forms] in StaticPtrTable. -} rnExpr e@(HsStatic _ expr) = do+ -- Normally, you wouldn't be able to construct a static expression without+ -- first enabling -XStaticPointers in the first place, since that extension+ -- is what makes the parser treat `static` as a keyword. But this is not a+ -- sufficient safeguard, as one can construct static expressions by another+ -- mechanism: Template Haskell (see #14204). To ensure that GHC is+ -- absolutely prepared to cope with static forms, we check for+ -- -XStaticPointers here as well.+ unlessXOptM LangExt.StaticPointers $+ addErr $ hang (text "Illegal static expression:" <+> ppr e)+ 2 (text "Use StaticPointers to enable this extension") (expr',fvExpr) <- rnLExpr expr stage <- getStage case stage of@@ -400,7 +423,7 @@ hsHoleExpr :: HsExpr id hsHoleExpr = HsUnboundVar (TrueExprHole (mkVarOcc "_")) -arrowFail :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars)+arrowFail :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars) arrowFail e = do { addErr (vcat [ text "Arrow command found where an expression was expected:" , nest 2 (ppr e) ])@@ -410,7 +433,7 @@ ---------------------- -- See Note [Parsing sections] in Parser.y-rnSection :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars)+rnSection :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars) rnSection section@(SectionR op expr) = do { (op', fvs_op) <- rnLExpr op ; (expr', fvs_expr) <- rnLExpr expr@@ -433,14 +456,14 @@ ************************************************************************ -} -rnCmdArgs :: [LHsCmdTop RdrName] -> RnM ([LHsCmdTop Name], FreeVars)+rnCmdArgs :: [LHsCmdTop GhcPs] -> RnM ([LHsCmdTop GhcRn], FreeVars) rnCmdArgs [] = return ([], emptyFVs) rnCmdArgs (arg:args) = do { (arg',fvArg) <- rnCmdTop arg ; (args',fvArgs) <- rnCmdArgs args ; return (arg':args', fvArg `plusFV` fvArgs) } -rnCmdTop :: LHsCmdTop RdrName -> RnM (LHsCmdTop Name, FreeVars)+rnCmdTop :: LHsCmdTop GhcPs -> RnM (LHsCmdTop GhcRn, FreeVars) rnCmdTop = wrapLocFstM rnCmdTop' where rnCmdTop' (HsCmdTop cmd _ _ _)@@ -454,10 +477,10 @@ (cmd_names `zip` cmd_names'), fvCmd `plusFV` cmd_fvs) } -rnLCmd :: LHsCmd RdrName -> RnM (LHsCmd Name, FreeVars)+rnLCmd :: LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars) rnLCmd = wrapLocFstM rnCmd -rnCmd :: HsCmd RdrName -> RnM (HsCmd Name, FreeVars)+rnCmd :: HsCmd GhcPs -> RnM (HsCmd GhcRn, FreeVars) rnCmd (HsCmdArrApp arrow arg _ ho rtl) = do { (arrow',fvArrow) <- select_arrow_scope (rnLExpr arrow)@@ -532,10 +555,10 @@ -- appAName, choiceAName, loopAName -- find what methods the Cmd needs (loop, choice, apply)-methodNamesLCmd :: LHsCmd Name -> CmdNeeds+methodNamesLCmd :: LHsCmd GhcRn -> CmdNeeds methodNamesLCmd = methodNamesCmd . unLoc -methodNamesCmd :: HsCmd Name -> CmdNeeds+methodNamesCmd :: HsCmd GhcRn -> CmdNeeds methodNamesCmd (HsCmdArrApp _arrow _arg _ HsFirstOrderApp _rtl) = emptyFVs@@ -563,31 +586,31 @@ -- The type checker will complain later ----------------------------------------------------methodNamesMatch :: MatchGroup Name (LHsCmd Name) -> FreeVars+methodNamesMatch :: MatchGroup GhcRn (LHsCmd GhcRn) -> FreeVars methodNamesMatch (MG { mg_alts = L _ ms }) = plusFVs (map do_one ms) where- do_one (L _ (Match _ _ _ grhss)) = methodNamesGRHSs grhss+ do_one (L _ (Match { m_grhss = grhss })) = methodNamesGRHSs grhss ------------------------------------------------- -- gaw 2004-methodNamesGRHSs :: GRHSs Name (LHsCmd Name) -> FreeVars+methodNamesGRHSs :: GRHSs GhcRn (LHsCmd GhcRn) -> FreeVars methodNamesGRHSs (GRHSs grhss _) = plusFVs (map methodNamesGRHS grhss) ------------------------------------------------- -methodNamesGRHS :: Located (GRHS Name (LHsCmd Name)) -> CmdNeeds+methodNamesGRHS :: Located (GRHS GhcRn (LHsCmd GhcRn)) -> CmdNeeds methodNamesGRHS (L _ (GRHS _ rhs)) = methodNamesLCmd rhs ----------------------------------------------------methodNamesStmts :: [Located (StmtLR Name Name (LHsCmd Name))] -> FreeVars+methodNamesStmts :: [Located (StmtLR GhcRn GhcRn (LHsCmd GhcRn))] -> FreeVars methodNamesStmts stmts = plusFVs (map methodNamesLStmt stmts) ----------------------------------------------------methodNamesLStmt :: Located (StmtLR Name Name (LHsCmd Name)) -> FreeVars+methodNamesLStmt :: Located (StmtLR GhcRn GhcRn (LHsCmd GhcRn)) -> FreeVars methodNamesLStmt = methodNamesStmt . unLoc -methodNamesStmt :: StmtLR Name Name (LHsCmd Name) -> FreeVars+methodNamesStmt :: StmtLR GhcRn GhcRn (LHsCmd GhcRn) -> FreeVars methodNamesStmt (LastStmt cmd _ _) = methodNamesLCmd cmd methodNamesStmt (BodyStmt cmd _ _ _) = methodNamesLCmd cmd methodNamesStmt (BindStmt _ cmd _ _ _) = methodNamesLCmd cmd@@ -608,7 +631,7 @@ ************************************************************************ -} -rnArithSeq :: ArithSeqInfo RdrName -> RnM (ArithSeqInfo Name, FreeVars)+rnArithSeq :: ArithSeqInfo GhcPs -> RnM (ArithSeqInfo GhcRn, FreeVars) rnArithSeq (From expr) = do { (expr', fvExpr) <- rnLExpr expr ; return (From expr', fvExpr) }@@ -660,34 +683,34 @@ -} -- | Rename some Stmts-rnStmts :: Outputable (body RdrName)+rnStmts :: Outputable (body GhcPs) => HsStmtContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -- ^ How to rename the body of each statement (e.g. rnLExpr)- -> [LStmt RdrName (Located (body RdrName))]+ -> [LStmt GhcPs (Located (body GhcPs))] -- ^ Statements -> ([Name] -> RnM (thing, FreeVars)) -- ^ if these statements scope over something, this renames it -- and returns the result.- -> RnM (([LStmt Name (Located (body Name))], thing), FreeVars)+ -> RnM (([LStmt GhcRn (Located (body GhcRn))], thing), FreeVars) rnStmts ctxt rnBody = rnStmtsWithPostProcessing ctxt rnBody noPostProcessStmts -- | like 'rnStmts' but applies a post-processing step to the renamed Stmts rnStmtsWithPostProcessing- :: Outputable (body RdrName)+ :: Outputable (body GhcPs) => HsStmtContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -- ^ How to rename the body of each statement (e.g. rnLExpr) -> (HsStmtContext Name- -> [(LStmt Name (Located (body Name)), FreeVars)]- -> RnM ([LStmt Name (Located (body Name))], FreeVars))+ -> [(LStmt GhcRn (Located (body GhcRn)), FreeVars)]+ -> RnM ([LStmt GhcRn (Located (body GhcRn))], FreeVars)) -- ^ postprocess the statements- -> [LStmt RdrName (Located (body RdrName))]+ -> [LStmt GhcPs (Located (body GhcPs))] -- ^ Statements -> ([Name] -> RnM (thing, FreeVars)) -- ^ if these statements scope over something, this renames it -- and returns the result.- -> RnM (([LStmt Name (Located (body Name))], thing), FreeVars)+ -> RnM (([LStmt GhcRn (Located (body GhcRn))], thing), FreeVars) rnStmtsWithPostProcessing ctxt rnBody ppStmts stmts thing_inside = do { ((stmts', thing), fvs) <- rnStmtsWithFreeVars ctxt rnBody stmts thing_inside@@ -698,8 +721,8 @@ -- | maybe rearrange statements according to the ApplicativeDo transformation postProcessStmtsForApplicativeDo :: HsStmtContext Name- -> [(ExprLStmt Name, FreeVars)]- -> RnM ([ExprLStmt Name], FreeVars)+ -> [(ExprLStmt GhcRn, FreeVars)]+ -> RnM ([ExprLStmt GhcRn], FreeVars) postProcessStmtsForApplicativeDo ctxt stmts = do { -- rearrange the statements using ApplicativeStmt if@@ -709,23 +732,24 @@ ; let is_do_expr | DoExpr <- ctxt = True | otherwise = False ; if ado_is_on && is_do_expr- then rearrangeForApplicativeDo ctxt stmts+ then do { traceRn "ppsfa" (ppr stmts)+ ; rearrangeForApplicativeDo ctxt stmts } else noPostProcessStmts ctxt stmts } -- | strip the FreeVars annotations from statements noPostProcessStmts :: HsStmtContext Name- -> [(LStmt Name (Located (body Name)), FreeVars)]- -> RnM ([LStmt Name (Located (body Name))], FreeVars)+ -> [(LStmt GhcRn (Located (body GhcRn)), FreeVars)]+ -> RnM ([LStmt GhcRn (Located (body GhcRn))], FreeVars) noPostProcessStmts _ stmts = return (map fst stmts, emptyNameSet) -rnStmtsWithFreeVars :: Outputable (body RdrName)+rnStmtsWithFreeVars :: Outputable (body GhcPs) => HsStmtContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> [LStmt RdrName (Located (body RdrName))]+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> [LStmt GhcPs (Located (body GhcPs))] -> ([Name] -> RnM (thing, FreeVars))- -> RnM ( ([(LStmt Name (Located (body Name)), FreeVars)], thing)+ -> RnM ( ([(LStmt GhcRn (Located (body GhcRn)), FreeVars)], thing) , FreeVars) -- Each Stmt body is annotated with its FreeVars, so that -- we can rearrange statements for ApplicativeDo.@@ -783,15 +807,15 @@ At one point we failed to make this distinction, leading to #11216. -} -rnStmt :: Outputable (body RdrName)+rnStmt :: Outputable (body GhcPs) => HsStmtContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -- ^ How to rename the body of the statement- -> LStmt RdrName (Located (body RdrName))+ -> LStmt GhcPs (Located (body GhcPs)) -- ^ The statement -> ([Name] -> RnM (thing, FreeVars)) -- ^ Rename the stuff that this statement scopes over- -> RnM ( ([(LStmt Name (Located (body Name)), FreeVars)], thing)+ -> RnM ( ([(LStmt GhcRn (Located (body GhcRn)), FreeVars)], thing) , FreeVars) -- Variables bound by the Stmt, and mentioned in thing_inside, -- do not appear in the result FreeVars@@ -824,7 +848,7 @@ ; xMonadFailEnabled <- fmap (xopt LangExt.MonadFailDesugaring) getDynFlags ; let getFailFunction- -- If the pattern is irrefutible (e.g.: wildcard, tuple,+ -- If the pattern is irrefutable (e.g.: wildcard, tuple, -- ~pat, etc.) we should not need to fail. | isIrrefutableHsPat pat = return (noSyntaxExpr, emptyFVs)@@ -929,18 +953,18 @@ panic "rnStmt: ApplicativeStmt" rnParallelStmts :: forall thing. HsStmtContext Name- -> SyntaxExpr Name- -> [ParStmtBlock RdrName RdrName]+ -> SyntaxExpr GhcRn+ -> [ParStmtBlock GhcPs GhcPs] -> ([Name] -> RnM (thing, FreeVars))- -> RnM (([ParStmtBlock Name Name], thing), FreeVars)+ -> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars) -- Note [Renaming parallel Stmts] rnParallelStmts ctxt return_op segs thing_inside = do { orig_lcl_env <- getLocalRdrEnv ; rn_segs orig_lcl_env [] segs } where rn_segs :: LocalRdrEnv- -> [Name] -> [ParStmtBlock RdrName RdrName]- -> RnM (([ParStmtBlock Name Name], thing), FreeVars)+ -> [Name] -> [ParStmtBlock GhcPs GhcPs]+ -> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars) rn_segs _ bndrs_so_far [] = do { let (bndrs', dups) = removeDups cmpByOcc bndrs_so_far ; mapM_ dupErr dups@@ -960,9 +984,9 @@ cmpByOcc n1 n2 = nameOccName n1 `compare` nameOccName n2 dupErr vs = addErr (text "Duplicate binding in parallel list comprehension for:"- <+> quotes (ppr (head vs)))+ <+> quotes (ppr (NE.head vs))) -lookupStmtName :: HsStmtContext Name -> Name -> RnM (SyntaxExpr Name, FreeVars)+lookupStmtName :: HsStmtContext Name -> Name -> RnM (SyntaxExpr GhcRn, FreeVars) -- Like lookupSyntaxName, but respects contexts lookupStmtName ctxt n | rebindableContext ctxt@@ -970,7 +994,7 @@ | otherwise = return (mkRnSyntaxExpr n, emptyFVs) -lookupStmtNamePoly :: HsStmtContext Name -> Name -> RnM (HsExpr Name, FreeVars)+lookupStmtNamePoly :: HsStmtContext Name -> Name -> RnM (HsExpr GhcRn, FreeVars) lookupStmtNamePoly ctxt name | rebindableContext ctxt = do { rebindable_on <- xoptM LangExt.RebindableSyntax@@ -1038,13 +1062,13 @@ -- wrapper that does both the left- and right-hand sides-rnRecStmtsAndThen :: Outputable (body RdrName) =>- (Located (body RdrName)- -> RnM (Located (body Name), FreeVars))- -> [LStmt RdrName (Located (body RdrName))]+rnRecStmtsAndThen :: Outputable (body GhcPs) =>+ (Located (body GhcPs)+ -> RnM (Located (body GhcRn), FreeVars))+ -> [LStmt GhcPs (Located (body GhcPs))] -- assumes that the FreeVars returned includes -- the FreeVars of the Segments- -> ([Segment (LStmt Name (Located (body Name)))]+ -> ([Segment (LStmt GhcRn (Located (body GhcRn)))] -> RnM (a, FreeVars)) -> RnM (a, FreeVars) rnRecStmtsAndThen rnBody s cont@@ -1068,7 +1092,7 @@ ; return (res, fvs) }} -- get all the fixity decls in any Let stmt-collectRecStmtsFixities :: [LStmtLR RdrName RdrName body] -> [LFixitySig RdrName]+collectRecStmtsFixities :: [LStmtLR GhcPs GhcPs body] -> [LFixitySig GhcPs] collectRecStmtsFixities l = foldr (\ s -> \acc -> case s of (L _ (LetStmt (L _ (HsValBinds (ValBindsIn _ sigs))))) ->@@ -1080,11 +1104,11 @@ -- left-hand sides rn_rec_stmt_lhs :: Outputable body => MiniFixityEnv- -> LStmt RdrName body+ -> LStmt GhcPs body -- rename LHS, and return its FVs -- Warning: we will only need the FreeVars below in the case of a BindStmt, -- so we don't bother to compute it accurately in the other cases- -> RnM [(LStmtLR Name RdrName body, FreeVars)]+ -> RnM [(LStmtLR GhcRn GhcPs body, FreeVars)] rn_rec_stmt_lhs _ (L loc (BodyStmt body a b c)) = return [(L loc (BodyStmt body a b c), emptyFVs)]@@ -1126,8 +1150,8 @@ = panic "rn_rec_stmt LetStmt EmptyLocalBinds" rn_rec_stmts_lhs :: Outputable body => MiniFixityEnv- -> [LStmt RdrName body]- -> RnM [(LStmtLR Name RdrName body, FreeVars)]+ -> [LStmt GhcPs body]+ -> RnM [(LStmtLR GhcRn GhcPs body, FreeVars)] rn_rec_stmts_lhs fix_env stmts = do { ls <- concatMapM (rn_rec_stmt_lhs fix_env) stmts ; let boundNames = collectLStmtsBinders (map fst ls)@@ -1140,11 +1164,11 @@ -- right-hand-sides -rn_rec_stmt :: (Outputable (body RdrName)) =>- (Located (body RdrName) -> RnM (Located (body Name), FreeVars))+rn_rec_stmt :: (Outputable (body GhcPs)) =>+ (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -> [Name]- -> (LStmtLR Name RdrName (Located (body RdrName)), FreeVars)- -> RnM [Segment (LStmt Name (Located (body Name)))]+ -> (LStmtLR GhcRn GhcPs (Located (body GhcPs)), FreeVars)+ -> RnM [Segment (LStmt GhcRn (Located (body GhcRn)))] -- Rename a Stmt that is inside a RecStmt (or mdo) -- Assumes all binders are already in scope -- Turns each stmt into a singleton Stmt@@ -1200,20 +1224,20 @@ rn_rec_stmt _ _ stmt@(L _ (ApplicativeStmt {}), _) = pprPanic "rn_rec_stmt: ApplicativeStmt" (ppr stmt) -rn_rec_stmts :: Outputable (body RdrName) =>- (Located (body RdrName) -> RnM (Located (body Name), FreeVars))+rn_rec_stmts :: Outputable (body GhcPs) =>+ (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars)) -> [Name]- -> [(LStmtLR Name RdrName (Located (body RdrName)), FreeVars)]- -> RnM [Segment (LStmt Name (Located (body Name)))]+ -> [(LStmtLR GhcRn GhcPs (Located (body GhcPs)), FreeVars)]+ -> RnM [Segment (LStmt GhcRn (Located (body GhcRn)))] rn_rec_stmts rnBody bndrs stmts = do { segs_s <- mapM (rn_rec_stmt rnBody bndrs) stmts ; return (concat segs_s) } --------------------------------------------- segmentRecStmts :: SrcSpan -> HsStmtContext Name- -> Stmt Name body- -> [Segment (LStmt Name body)] -> FreeVars- -> ([LStmt Name body], FreeVars)+ -> Stmt GhcRn body+ -> [Segment (LStmt GhcRn body)] -> FreeVars+ -> ([LStmt GhcRn body], FreeVars) segmentRecStmts loc ctxt empty_rec_stmt segs fvs_later | null segs@@ -1315,8 +1339,9 @@ -} glomSegments :: HsStmtContext Name- -> [Segment (LStmt Name body)]- -> [Segment [LStmt Name body]] -- Each segment has a non-empty list of Stmts+ -> [Segment (LStmt GhcRn body)]+ -> [Segment [LStmt GhcRn body]]+ -- Each segment has a non-empty list of Stmts -- See Note [Glomming segments] glomSegments _ [] = []@@ -1345,10 +1370,12 @@ not_needed (defs,_,_,_) = not (intersectsNameSet defs uses) -----------------------------------------------------segsToStmts :: Stmt Name body -- A RecStmt with the SyntaxOps filled in- -> [Segment [LStmt Name body]] -- Each Segment has a non-empty list of Stmts- -> FreeVars -- Free vars used 'later'- -> ([LStmt Name body], FreeVars)+segsToStmts :: Stmt GhcRn body+ -- A RecStmt with the SyntaxOps filled in+ -> [Segment [LStmt GhcRn body]]+ -- Each Segment has a non-empty list of Stmts+ -> FreeVars -- Free vars used 'later'+ -> ([LStmt GhcRn body], FreeVars) segsToStmts _ [] fvs_later = ([], fvs_later) segsToStmts empty_rec_stmt ((defs, uses, fwds, ss) : segs) fvs_later@@ -1490,8 +1517,8 @@ -- Note [ApplicativeDo]. rearrangeForApplicativeDo :: HsStmtContext Name- -> [(ExprLStmt Name, FreeVars)]- -> RnM ([ExprLStmt Name], FreeVars)+ -> [(ExprLStmt GhcRn, FreeVars)]+ -> RnM ([ExprLStmt GhcRn], FreeVars) rearrangeForApplicativeDo _ [] = return ([], emptyNameSet) rearrangeForApplicativeDo _ [(one,_)] = return ([one], emptyNameSet)@@ -1499,6 +1526,7 @@ optimal_ado <- goptM Opt_OptimalApplicativeDo let stmt_tree | optimal_ado = mkStmtTreeOptimal stmts | otherwise = mkStmtTreeHeuristic stmts+ traceRn "rearrangeForADo" (ppr stmt_tree) return_name <- lookupSyntaxName' returnMName pure_name <- lookupSyntaxName' pureAName let monad_names = MonadNames { return_name = return_name@@ -1516,6 +1544,13 @@ | StmtTreeBind (StmtTree a) (StmtTree a) | StmtTreeApplicative [StmtTree a] +instance Outputable a => Outputable (StmtTree a) where+ ppr (StmtTreeOne x) = parens (text "StmtTreeOne" <+> ppr x)+ ppr (StmtTreeBind x y) = parens (hang (text "StmtTreeBind")+ 2 (sep [ppr x, ppr y]))+ ppr (StmtTreeApplicative xs) = parens (hang (text "StmtTreeApplicative")+ 2 (vcat (map ppr xs)))+ flattenStmtTree :: StmtTree a -> [a] flattenStmtTree t = go t [] where@@ -1523,12 +1558,12 @@ go (StmtTreeBind l r) as = go l (go r as) go (StmtTreeApplicative ts) as = foldr go as ts -type ExprStmtTree = StmtTree (ExprLStmt Name, FreeVars)+type ExprStmtTree = StmtTree (ExprLStmt GhcRn, FreeVars) type Cost = Int -- | Turn a sequence of statements into an ExprStmtTree using a -- heuristic algorithm. /O(n^2)/-mkStmtTreeHeuristic :: [(ExprLStmt Name, FreeVars)] -> ExprStmtTree+mkStmtTreeHeuristic :: [(ExprLStmt GhcRn, FreeVars)] -> ExprStmtTree mkStmtTreeHeuristic [one] = StmtTreeOne one mkStmtTreeHeuristic stmts = case segments stmts of@@ -1542,7 +1577,7 @@ -- | Turn a sequence of statements into an ExprStmtTree optimally, -- using dynamic programming. /O(n^3)/-mkStmtTreeOptimal :: [(ExprLStmt Name, FreeVars)] -> ExprStmtTree+mkStmtTreeOptimal :: [(ExprLStmt GhcRn, FreeVars)] -> ExprStmtTree mkStmtTreeOptimal stmts = ASSERT(not (null stmts)) -- the empty case is handled by the caller; -- we don't support empty StmtTrees.@@ -1609,9 +1644,9 @@ :: MonadNames -> HsStmtContext Name -> ExprStmtTree- -> [ExprLStmt Name] -- ^ the "tail"+ -> [ExprLStmt GhcRn] -- ^ the "tail" -> FreeVars -- ^ free variables of the tail- -> RnM ( [ExprLStmt Name] -- ( output statements,+ -> RnM ( [ExprLStmt GhcRn] -- ( output statements, , FreeVars ) -- , things we needed -- If we have a single bind, and we can do it without a join, transform@@ -1624,7 +1659,12 @@ tail _tail_fvs | not (isStrictPattern pat), (False,tail') <- needJoin monad_names tail -- See Note [ApplicativeDo and strict patterns]- = mkApplicativeStmt ctxt [ApplicativeArgOne pat rhs] False tail'+ = mkApplicativeStmt ctxt [ApplicativeArgOne pat rhs False] False tail'+stmtTreeToStmts monad_names ctxt (StmtTreeOne (L _ (BodyStmt rhs _ _ _),_))+ tail _tail_fvs+ | (False,tail') <- needJoin monad_names tail+ = mkApplicativeStmt ctxt+ [ApplicativeArgOne nlWildPatName rhs True] False tail' stmtTreeToStmts _monad_names _ctxt (StmtTreeOne (s,_)) tail _tail_fvs = return (s : tail, emptyNameSet)@@ -1643,7 +1683,9 @@ return (stmts, unionNameSets (fvs:fvss)) where stmtTreeArg _ctxt _tail_fvs (StmtTreeOne (L _ (BindStmt pat exp _ _ _), _)) =- return (ApplicativeArgOne pat exp, emptyFVs)+ return (ApplicativeArgOne pat exp False, emptyFVs)+ stmtTreeArg _ctxt _tail_fvs (StmtTreeOne (L _ (BodyStmt exp _ _ _), _)) =+ return (ApplicativeArgOne nlWildPatName exp True, emptyFVs) stmtTreeArg ctxt tail_fvs tree = do let stmts = flattenStmtTree tree pvarset = mkNameSet (concatMap (collectStmtBinders.unLoc.fst) stmts)@@ -1666,8 +1708,8 @@ -- | Divide a sequence of statements into segments, where no segment -- depends on any variables defined by a statement in another segment. segments- :: [(ExprLStmt Name, FreeVars)]- -> [[(ExprLStmt Name, FreeVars)]]+ :: [(ExprLStmt GhcRn, FreeVars)]+ -> [[(ExprLStmt GhcRn, FreeVars)]] segments stmts = map fst $ merge $ reverse $ map reverse $ walk (reverse stmts) where allvars = mkNameSet (concatMap (collectStmtBinders.unLoc.fst) stmts)@@ -1689,7 +1731,7 @@ -- the sequence from the back to the front, and keeping track of -- the set of free variables of the current segment. Whenever -- this set of free variables is empty, we have a complete segment.- walk :: [(ExprLStmt Name, FreeVars)] -> [[(ExprLStmt Name, FreeVars)]]+ walk :: [(ExprLStmt GhcRn, FreeVars)] -> [[(ExprLStmt GhcRn, FreeVars)]] walk [] = [] walk ((stmt,fvs) : stmts) = ((stmt,fvs) : seg) : walk rest where (seg,rest) = chunter fvs' stmts@@ -1712,7 +1754,7 @@ where fvs' = fvs `intersectNameSet` allvars pvars = mkNameSet (collectStmtBinders (unLoc stmt)) - isStrictPatternBind :: ExprLStmt Name -> Bool+ isStrictPatternBind :: ExprLStmt GhcRn -> Bool isStrictPatternBind (L _ (BindStmt pat _ _ _ _)) = isStrictPattern pat isStrictPatternBind _ = False @@ -1753,6 +1795,7 @@ SigPatIn p _ -> isStrictPattern p SigPatOut p _ -> isStrictPattern p BangPat{} -> True+ ListPat{} -> True TuplePat{} -> True SumPat{} -> True PArrPat{} -> True@@ -1773,9 +1816,9 @@ -- heuristic is to peel off the first group of independent statements -- and put the bind after those. splitSegment- :: [(ExprLStmt Name, FreeVars)]- -> ( [(ExprLStmt Name, FreeVars)]- , [(ExprLStmt Name, FreeVars)] )+ :: [(ExprLStmt GhcRn, FreeVars)]+ -> ( [(ExprLStmt GhcRn, FreeVars)]+ , [(ExprLStmt GhcRn, FreeVars)] ) splitSegment [one,two] = ([one],[two]) -- there is no choice when there are only two statements; this just saves -- some work in a common case.@@ -1790,10 +1833,10 @@ _other -> (stmts,[]) slurpIndependentStmts- :: [(LStmt Name (Located (body Name)), FreeVars)]- -> Maybe ( [(LStmt Name (Located (body Name)), FreeVars)] -- LetStmts- , [(LStmt Name (Located (body Name)), FreeVars)] -- BindStmts- , [(LStmt Name (Located (body Name)), FreeVars)] )+ :: [(LStmt GhcRn (Located (body GhcRn)), FreeVars)]+ -> Maybe ( [(LStmt GhcRn (Located (body GhcRn)), FreeVars)] -- LetStmts+ , [(LStmt GhcRn (Located (body GhcRn)), FreeVars)] -- BindStmts+ , [(LStmt GhcRn (Located (body GhcRn)), FreeVars)] ) slurpIndependentStmts stmts = go [] [] emptyNameSet stmts where -- If we encounter a BindStmt that doesn't depend on a previous BindStmt@@ -1833,10 +1876,10 @@ -- typechecker and the desugarer (I tried it that way first!). mkApplicativeStmt :: HsStmtContext Name- -> [ApplicativeArg Name Name] -- ^ The args+ -> [ApplicativeArg GhcRn GhcRn] -- ^ The args -> Bool -- ^ True <=> need a join- -> [ExprLStmt Name] -- ^ The body statements- -> RnM ([ExprLStmt Name], FreeVars)+ -> [ExprLStmt GhcRn] -- ^ The body statements+ -> RnM ([ExprLStmt GhcRn], FreeVars) mkApplicativeStmt ctxt args need_join body_stmts = do { (fmap_op, fvs1) <- lookupStmtName ctxt fmapName ; (ap_op, fvs2) <- lookupStmtName ctxt apAName@@ -1856,8 +1899,8 @@ -- | Given the statements following an ApplicativeStmt, determine whether -- we need a @join@ or not, and remove the @return@ if necessary. needJoin :: MonadNames- -> [ExprLStmt Name]- -> (Bool, [ExprLStmt Name])+ -> [ExprLStmt GhcRn]+ -> (Bool, [ExprLStmt GhcRn]) needJoin _monad_names [] = (False, []) -- we're in an ApplicativeArg needJoin monad_names [L loc (LastStmt e _ t)] | Just arg <- isReturnApp monad_names e =@@ -1867,8 +1910,8 @@ -- | @Just e@, if the expression is @return e@ or @return $ e@, -- otherwise @Nothing@ isReturnApp :: MonadNames- -> LHsExpr Name- -> Maybe (LHsExpr Name)+ -> LHsExpr GhcRn+ -> Maybe (LHsExpr GhcRn) isReturnApp monad_names (L _ (HsPar expr)) = isReturnApp monad_names expr isReturnApp monad_names (L _ e) = case e of OpApp l op _ r | is_return l, is_dollar op -> Just r@@ -1908,9 +1951,9 @@ emptyErr ctxt = text "Empty" <+> pprStmtContext ctxt -----------------------checkLastStmt :: Outputable (body RdrName) => HsStmtContext Name- -> LStmt RdrName (Located (body RdrName))- -> RnM (LStmt RdrName (Located (body RdrName)))+checkLastStmt :: Outputable (body GhcPs) => HsStmtContext Name+ -> LStmt GhcPs (Located (body GhcPs))+ -> RnM (LStmt GhcPs (Located (body GhcPs))) checkLastStmt ctxt lstmt@(L loc stmt) = case ctxt of ListComp -> check_comp@@ -1940,7 +1983,7 @@ -- Checking when a particular Stmt is ok checkStmt :: HsStmtContext Name- -> LStmt RdrName (Located (body RdrName))+ -> LStmt GhcPs (Located (body GhcPs)) -> RnM () checkStmt ctxt (L _ stmt) = do { dflags <- getDynFlags@@ -1967,9 +2010,9 @@ okStmt, okDoStmt, okCompStmt, okParStmt, okPArrStmt :: DynFlags -> HsStmtContext Name- -> Stmt RdrName (Located (body RdrName)) -> Validity+ -> Stmt GhcPs (Located (body GhcPs)) -> Validity -- Return Nothing if OK, (Just extra) if not ok--- The "extra" is an SDoc that is appended to an generic error message+-- The "extra" is an SDoc that is appended to a generic error message okStmt dflags ctxt stmt = case ctxt of@@ -1985,7 +2028,7 @@ TransStmtCtxt ctxt -> okStmt dflags ctxt stmt --------------okPatGuardStmt :: Stmt RdrName (Located (body RdrName)) -> Validity+okPatGuardStmt :: Stmt GhcPs (Located (body GhcPs)) -> Validity okPatGuardStmt stmt = case stmt of BodyStmt {} -> IsValid@@ -2042,7 +2085,7 @@ ApplicativeStmt {} -> emptyInvalid ----------checkTupleSection :: [LHsTupArg RdrName] -> RnM ()+checkTupleSection :: [LHsTupArg GhcPs] -> RnM () checkTupleSection args = do { tuple_section <- xoptM LangExt.TupleSections ; checkErr (all tupArgPresent args || tuple_section) msg }@@ -2050,12 +2093,12 @@ msg = text "Illegal tuple section: use TupleSections" ----------sectionErr :: HsExpr RdrName -> SDoc+sectionErr :: HsExpr GhcPs -> SDoc sectionErr expr = hang (text "A section must be enclosed in parentheses") 2 (text "thus:" <+> (parens (ppr expr))) -patSynErr :: HsExpr RdrName -> SDoc -> RnM (HsExpr Name, FreeVars)+patSynErr :: HsExpr GhcPs -> SDoc -> RnM (HsExpr GhcRn, FreeVars) patSynErr e explanation = do { addErr (sep [text "Pattern syntax in expression context:", nest 4 (ppr e)] $$ explanation)
rename/RnExpr.hs-boot view
@@ -1,18 +1,18 @@ module RnExpr where+import Name import HsSyn-import Name ( Name )-import NameSet ( FreeVars )-import RdrName ( RdrName )+import NameSet ( FreeVars ) import TcRnTypes-import SrcLoc ( Located )-import Outputable ( Outputable )+import SrcLoc ( Located )+import Outputable ( Outputable )+import HsExtension ( GhcPs, GhcRn ) -rnLExpr :: LHsExpr RdrName- -> RnM (LHsExpr Name, FreeVars)+rnLExpr :: LHsExpr GhcPs+ -> RnM (LHsExpr GhcRn, FreeVars) rnStmts :: --forall thing body.- Outputable (body RdrName) => HsStmtContext Name- -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))- -> [LStmt RdrName (Located (body RdrName))]+ Outputable (body GhcPs) => HsStmtContext Name+ -> (Located (body GhcPs) -> RnM (Located (body GhcRn), FreeVars))+ -> [LStmt GhcPs (Located (body GhcPs))] -> ([Name] -> RnM (thing, FreeVars))- -> RnM (([LStmt Name (Located (body Name))], thing), FreeVars)+ -> RnM (([LStmt GhcRn (Located (body GhcRn))], thing), FreeVars)
+ rename/RnFixity.hs view
@@ -0,0 +1,211 @@+{-++This module contains code which maintains and manipulates the+fixity environment during renaming.++-}+module RnFixity ( MiniFixityEnv,+ addLocalFixities,+ lookupFixityRn, lookupFixityRn_help,+ lookupFieldFixityRn, lookupTyFixityRn ) where++import GhcPrelude++import LoadIface+import HsSyn+import RdrName+import HscTypes+import TcRnMonad+import Name+import NameEnv+import Module+import BasicTypes ( Fixity(..), FixityDirection(..), minPrecedence,+ defaultFixity, SourceText(..) )+import SrcLoc+import Outputable+import Maybes+import Data.List+import Data.Function ( on )+import RnUnbound++{-+*********************************************************+* *+ Fixities+* *+*********************************************************++Note [Fixity signature lookup]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A fixity declaration like++ infixr 2 ?++can refer to a value-level operator, e.g.:++ (?) :: String -> String -> String++or a type-level operator, like:++ data (?) a b = A a | B b++so we extend the lookup of the reader name '?' to the TcClsName namespace, as+well as the original namespace.++The extended lookup is also used in other places, like resolution of+deprecation declarations, and lookup of names in GHCi.+-}++--------------------------------+type MiniFixityEnv = FastStringEnv (Located Fixity)+ -- Mini fixity env for the names we're about+ -- to bind, in a single binding group+ --+ -- It is keyed by the *FastString*, not the *OccName*, because+ -- the single fixity decl infix 3 T+ -- affects both the data constructor T and the type constrctor T+ --+ -- We keep the location so that if we find+ -- a duplicate, we can report it sensibly++--------------------------------+-- Used for nested fixity decls to bind names along with their fixities.+-- the fixities are given as a UFM from an OccName's FastString to a fixity decl++addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a+addLocalFixities mini_fix_env names thing_inside+ = extendFixityEnv (mapMaybe find_fixity names) thing_inside+ where+ find_fixity name+ = case lookupFsEnv mini_fix_env (occNameFS occ) of+ Just (L _ fix) -> Just (name, FixItem occ fix)+ Nothing -> Nothing+ where+ occ = nameOccName name++{-+--------------------------------+lookupFixity is a bit strange.++* Nested local fixity decls are put in the local fixity env, which we+ find with getFixtyEnv++* Imported fixities are found in the PIT++* Top-level fixity decls in this module may be for Names that are+ either Global (constructors, class operations)+ or Local/Exported (everything else)+ (See notes with RnNames.getLocalDeclBinders for why we have this split.)+ We put them all in the local fixity environment+-}++lookupFixityRn :: Name -> RnM Fixity+lookupFixityRn name = lookupFixityRn' name (nameOccName name)++lookupFixityRn' :: Name -> OccName -> RnM Fixity+lookupFixityRn' name = fmap snd . lookupFixityRn_help' name++-- | 'lookupFixityRn_help' returns @(True, fixity)@ if it finds a 'Fixity'+-- in a local environment or from an interface file. Otherwise, it returns+-- @(False, fixity)@ (e.g., for unbound 'Name's or 'Name's without+-- user-supplied fixity declarations).+lookupFixityRn_help :: Name+ -> RnM (Bool, Fixity)+lookupFixityRn_help name =+ lookupFixityRn_help' name (nameOccName name)++lookupFixityRn_help' :: Name+ -> OccName+ -> RnM (Bool, Fixity)+lookupFixityRn_help' name occ+ | isUnboundName name+ = return (False, Fixity NoSourceText minPrecedence InfixL)+ -- Minimise errors from ubound names; eg+ -- a>0 `foo` b>0+ -- where 'foo' is not in scope, should not give an error (Trac #7937)++ | otherwise+ = do { local_fix_env <- getFixityEnv+ ; case lookupNameEnv local_fix_env name of {+ Just (FixItem _ fix) -> return (True, fix) ;+ Nothing ->++ do { this_mod <- getModule+ ; if nameIsLocalOrFrom this_mod name+ -- Local (and interactive) names are all in the+ -- fixity env, and don't have entries in the HPT+ then return (False, defaultFixity)+ else lookup_imported } } }+ where+ lookup_imported+ -- For imported names, we have to get their fixities by doing a+ -- loadInterfaceForName, and consulting the Ifaces that comes back+ -- from that, because the interface file for the Name might not+ -- have been loaded yet. Why not? Suppose you import module A,+ -- which exports a function 'f', thus;+ -- module CurrentModule where+ -- import A( f )+ -- module A( f ) where+ -- import B( f )+ -- Then B isn't loaded right away (after all, it's possible that+ -- nothing from B will be used). When we come across a use of+ -- 'f', we need to know its fixity, and it's then, and only+ -- then, that we load B.hi. That is what's happening here.+ --+ -- loadInterfaceForName will find B.hi even if B is a hidden module,+ -- and that's what we want.+ = do { iface <- loadInterfaceForName doc name+ ; let mb_fix = mi_fix_fn iface occ+ ; let msg = case mb_fix of+ Nothing ->+ text "looking up name" <+> ppr name+ <+> text "in iface, but found no fixity for it."+ <+> text "Using default fixity instead."+ Just f ->+ text "looking up name in iface and found:"+ <+> vcat [ppr name, ppr f]+ ; traceRn "lookupFixityRn_either:" msg+ ; return (maybe (False, defaultFixity) (\f -> (True, f)) mb_fix) }++ doc = text "Checking fixity for" <+> ppr name++---------------+lookupTyFixityRn :: Located Name -> RnM Fixity+lookupTyFixityRn (L _ n) = lookupFixityRn n++-- | Look up the fixity of a (possibly ambiguous) occurrence of a record field+-- selector. We use 'lookupFixityRn'' so that we can specifiy the 'OccName' as+-- the field label, which might be different to the 'OccName' of the selector+-- 'Name' if @DuplicateRecordFields@ is in use (Trac #1173). If there are+-- multiple possible selectors with different fixities, generate an error.+lookupFieldFixityRn :: AmbiguousFieldOcc GhcRn -> RnM Fixity+lookupFieldFixityRn (Unambiguous (L _ rdr) n)+ = lookupFixityRn' n (rdrNameOcc rdr)+lookupFieldFixityRn (Ambiguous (L _ rdr) _) = get_ambiguous_fixity rdr+ where+ get_ambiguous_fixity :: RdrName -> RnM Fixity+ get_ambiguous_fixity rdr_name = do+ traceRn "get_ambiguous_fixity" (ppr rdr_name)+ rdr_env <- getGlobalRdrEnv+ let elts = lookupGRE_RdrName rdr_name rdr_env++ fixities <- groupBy ((==) `on` snd) . zip elts+ <$> mapM lookup_gre_fixity elts++ case fixities of+ -- There should always be at least one fixity.+ -- Something's very wrong if there are no fixity candidates, so panic+ [] -> panic "get_ambiguous_fixity: no candidates for a given RdrName"+ [ (_, fix):_ ] -> return fix+ ambigs -> addErr (ambiguous_fixity_err rdr_name ambigs)+ >> return (Fixity NoSourceText minPrecedence InfixL)++ lookup_gre_fixity gre = lookupFixityRn' (gre_name gre) (greOccName gre)++ ambiguous_fixity_err rn ambigs+ = vcat [ text "Ambiguous fixity for record field" <+> quotes (ppr rn)+ , hang (text "Conflicts: ") 2 . vcat .+ map format_ambig $ concat ambigs ]++ format_ambig (elt, fix) = hang (ppr fix)+ 2 (pprNameProvenance elt)
rename/RnHsDoc.hs view
@@ -1,6 +1,8 @@ module RnHsDoc ( rnHsDoc, rnLHsDoc, rnMbLHsDoc ) where +import GhcPrelude+ import TcRnTypes import HsSyn import SrcLoc
rename/RnNames.hs view
@@ -5,6 +5,10 @@ -} {-# LANGUAGE CPP, NondecreasingIndentation, MultiWayIf, NamedFieldPuns #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-} module RnNames ( rnImports, getLocalNonValBinders, newRecordSelector,@@ -15,15 +19,20 @@ checkConName, mkChildEnv, findChildren,- dodgyMsg+ dodgyMsg,+ dodgyMsgInsert ) where #include "HsVersions.h" +import GhcPrelude+ import DynFlags import HsSyn import TcEnv import RnEnv+import RnFixity+import RnUtils ( warnUnusedTopBinds, mkFieldEnv ) import LoadIface ( loadSrcInterface ) import TcRnMonad import PrelNames@@ -152,8 +161,8 @@ -- the return types represent. -- Note: Do the non SOURCE ones first, so that we get a helpful warning -- for SOURCE ones that are unnecessary-rnImports :: [LImportDecl RdrName]- -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails, AnyHpcUsage)+rnImports :: [LImportDecl GhcPs]+ -> RnM ([LImportDecl GhcRn], GlobalRdrEnv, ImportAvails, AnyHpcUsage) rnImports imports = do tcg_env <- getGblEnv -- NB: want an identity module here, because it's OK for a signature@@ -168,8 +177,8 @@ return (decls, rdr_env, imp_avails, hpc_usage) where- combine :: [(LImportDecl Name, GlobalRdrEnv, ImportAvails, AnyHpcUsage)]- -> ([LImportDecl Name], GlobalRdrEnv, ImportAvails, AnyHpcUsage)+ combine :: [(LImportDecl GhcRn, GlobalRdrEnv, ImportAvails, AnyHpcUsage)]+ -> ([LImportDecl GhcRn], GlobalRdrEnv, ImportAvails, AnyHpcUsage) combine = foldr plus ([], emptyGlobalRdrEnv, emptyImportAvails, False) plus (decl, gbl_env1, imp_avails1,hpc_usage1)@@ -194,8 +203,8 @@ -- -- 4. A boolean 'AnyHpcUsage' which is true if the imported module -- used HPC.-rnImportDecl :: Module -> LImportDecl RdrName- -> RnM (LImportDecl Name, GlobalRdrEnv, ImportAvails, AnyHpcUsage)+rnImportDecl :: Module -> LImportDecl GhcPs+ -> RnM (LImportDecl GhcRn, GlobalRdrEnv, ImportAvails, AnyHpcUsage) rnImportDecl this_mod (L loc decl@(ImportDecl { ideclName = loc_imp_mod_name, ideclPkgQual = mb_pkg , ideclSource = want_boot, ideclSafe = mod_safe@@ -259,8 +268,7 @@ -- the non-boot module depends on the compilation order, which -- is not deterministic. The hs-boot test can show this up. dflags <- getDynFlags- warnIf NoReason- (want_boot && not (mi_boot iface) && isOneShot (ghcMode dflags))+ warnIf (want_boot && not (mi_boot iface) && isOneShot (ghcMode dflags)) (warnRedundantSourceImport imp_mod_name) when (mod_safe && not (safeImportsOn dflags)) $ addErr (text "safe import can't be used as Safe Haskell isn't on!"@@ -541,7 +549,7 @@ * * ********************************************************************* -} -getLocalNonValBinders :: MiniFixityEnv -> HsGroup RdrName+getLocalNonValBinders :: MiniFixityEnv -> HsGroup GhcPs -> RnM ((TcGblEnv, TcLclEnv), NameSet) -- Get all the top-level binders bound the group *except* -- for value bindings, which are treated separately@@ -612,7 +620,7 @@ new_simple rdr_name = do{ nm <- newTopSrcBinder rdr_name ; return (avail nm) } - new_tc :: Bool -> LTyClDecl RdrName+ new_tc :: Bool -> LTyClDecl GhcPs -> RnM (AvailInfo, [(Name, [FieldLabel])]) new_tc overload_ok tc_decl -- NOT for type/data instances = do { let (bndrs, flds) = hsLTyClDeclBinders tc_decl@@ -627,7 +635,8 @@ -- Calculate the mapping from constructor names to fields, which -- will go in tcg_field_env. It's convenient to do this here where -- we are working with a single datatype definition.- mk_fld_env :: HsDataDefn RdrName -> [Name] -> [FieldLabel] -> [(Name, [FieldLabel])]+ mk_fld_env :: HsDataDefn GhcPs -> [Name] -> [FieldLabel]+ -> [(Name, [FieldLabel])] mk_fld_env d names flds = concatMap find_con_flds (dd_cons d) where find_con_flds (L _ (ConDeclH98 { con_name = L _ rdr@@ -660,7 +669,7 @@ find (\ fl -> flLabel fl == lbl) flds where lbl = occNameFS (rdrNameOcc rdr) - new_assoc :: Bool -> LInstDecl RdrName+ new_assoc :: Bool -> LInstDecl GhcPs -> RnM ([AvailInfo], [(Name, [FieldLabel])]) new_assoc _ (L _ (TyFamInstD {})) = return ([], []) -- type instances don't bind new names@@ -679,23 +688,24 @@ = return ([], []) -- Do not crash on ill-formed instances -- Eg instance !Show Int Trac #3811c - new_di :: Bool -> Maybe Name -> DataFamInstDecl RdrName+ new_di :: Bool -> Maybe Name -> DataFamInstDecl GhcPs -> RnM (AvailInfo, [(Name, [FieldLabel])])- new_di overload_ok mb_cls ti_decl- = do { main_name <- lookupFamInstName mb_cls (dfid_tycon ti_decl)- ; let (bndrs, flds) = hsDataFamInstBinders ti_decl+ new_di overload_ok mb_cls dfid@(DataFamInstDecl { dfid_eqn =+ HsIB { hsib_body = ti_decl }})+ = do { main_name <- lookupFamInstName mb_cls (feqn_tycon ti_decl)+ ; let (bndrs, flds) = hsDataFamInstBinders dfid ; sub_names <- mapM newTopSrcBinder bndrs ; flds' <- mapM (newRecordSelector overload_ok sub_names) flds ; let avail = AvailTC (unLoc main_name) sub_names flds' -- main_name is not bound here!- fld_env = mk_fld_env (dfid_defn ti_decl) sub_names flds'+ fld_env = mk_fld_env (feqn_rhs ti_decl) sub_names flds' ; return (avail, fld_env) } - new_loc_di :: Bool -> Maybe Name -> LDataFamInstDecl RdrName+ new_loc_di :: Bool -> Maybe Name -> LDataFamInstDecl GhcPs -> RnM (AvailInfo, [(Name, [FieldLabel])]) new_loc_di overload_ok mb_cls (L _ d) = new_di overload_ok mb_cls d -newRecordSelector :: Bool -> [Name] -> LFieldOcc RdrName -> RnM FieldLabel+newRecordSelector :: Bool -> [Name] -> LFieldOcc GhcPs -> RnM FieldLabel newRecordSelector _ [] _ = error "newRecordSelector: datatype has no constructors!" newRecordSelector overload_ok (dc:_) (L loc (FieldOcc (L _ fld) _)) = do { selName <- newTopSrcBinder $ L loc $ field@@ -755,7 +765,7 @@ Then M's export_avails are (recall the AvailTC invariant from Avails.hs) C(C,T), T(T,T1,T2,T3) Notice that T appears *twice*, once as a child and once as a parent. From-this list we construt a raw list including+this list we construct a raw list including T -> (T, T( T1, T2, T3 ), Nothing) T -> (C, C( C, T ), Nothing) and we combine these (in function 'combine' in 'imp_occ_env' in@@ -778,8 +788,8 @@ filterImports :: ModIface -> ImpDeclSpec -- The span for the entire import decl- -> Maybe (Bool, Located [LIE RdrName]) -- Import spec; True => hiding- -> RnM (Maybe (Bool, Located [LIE Name]), -- Import spec w/ Names+ -> Maybe (Bool, Located [LIE GhcPs]) -- Import spec; True => hiding+ -> RnM (Maybe (Bool, Located [LIE GhcRn]), -- Import spec w/ Names [GlobalRdrElt]) -- Same again, but in GRE form filterImports iface decl_spec Nothing = return (Nothing, gresFromAvails (Just imp_spec) (mi_exports iface))@@ -791,7 +801,7 @@ = do -- check for errors, convert RdrNames to Names items1 <- mapM lookup_lie import_items - let items2 :: [(LIE Name, AvailInfo)]+ let items2 :: [(LIE GhcRn, AvailInfo)] items2 = concat items1 -- NB the AvailInfo may have duplicates, and several items -- for the same parent; e.g N(x) and N(y)@@ -809,7 +819,7 @@ all_avails = mi_exports iface -- See Note [Dealing with imports]- imp_occ_env :: OccEnv (Name, -- the name+ imp_occ_env :: OccEnv (Name, -- the name AvailInfo, -- the export item providing the name Maybe Name) -- the parent of associated types imp_occ_env = mkOccEnv_C combine [ (nameOccName n, (n, a, Nothing))@@ -835,7 +845,7 @@ where mb_success = lookupOccEnv imp_occ_env (rdrNameOcc rdr) - lookup_lie :: LIE RdrName -> TcRn [(LIE Name, AvailInfo)]+ lookup_lie :: LIE GhcPs -> TcRn [(LIE GhcRn, AvailInfo)] lookup_lie (L loc ieRdr) = do (stuff, warns) <- setSrcSpan loc $ liftM (fromMaybe ([],[])) $@@ -871,7 +881,8 @@ -- data constructors of an associated family, we need separate -- AvailInfos for the data constructors and the family (as they have -- different parents). See Note [Dealing with imports]- lookup_ie :: IE RdrName -> IELookupM ([(IE Name, AvailInfo)], [IELookupWarning])+ lookup_ie :: IE GhcPs+ -> IELookupM ([(IE GhcRn, AvailInfo)], [IELookupWarning]) lookup_ie ie = handle_bad_import $ do case ie of IEVar (L l n) -> do@@ -1005,7 +1016,7 @@ -} -- | Given an import\/export spec, construct the appropriate 'GlobalRdrElt's.-gresFromIE :: ImpDeclSpec -> (LIE Name, AvailInfo) -> [GlobalRdrElt]+gresFromIE :: ImpDeclSpec -> (LIE GhcRn, AvailInfo) -> [GlobalRdrElt] gresFromIE decl_spec (L loc ie, avail) = gresFromAvail prov_fn avail where@@ -1079,7 +1090,7 @@ ********************************************************* -} -reportUnusedNames :: Maybe (Located [LIE RdrName]) -- Export list+reportUnusedNames :: Maybe (Located [LIE GhcPs]) -- Export list -> TcGblEnv -> RnM () reportUnusedNames _export_decls gbl_env = do { traceRn "RUN" (ppr (tcg_dus gbl_env))@@ -1135,9 +1146,9 @@ -} type ImportDeclUsage- = ( LImportDecl Name -- The import declaration+ = ( LImportDecl GhcRn -- The import declaration , [AvailInfo] -- What *is* used (normalised)- , [Name] ) -- What is imported but *not* used+ , [Name] ) -- What is imported but *not* used warnUnusedImportDecls :: TcGblEnv -> RnM () warnUnusedImportDecls gbl_env@@ -1198,6 +1209,7 @@ name = patSynName p pp_ty = pprPatSynType p + add_bind_warn :: Id -> IOEnv (Env TcGblEnv TcLclEnv) () add_bind_warn id = do { env <- tcInitTidyEnv -- Why not use emptyTidyEnv? ; let name = idName id@@ -1219,7 +1231,7 @@ {- Note [The ImportMap] ~~~~~~~~~~~~~~~~~~~~-The ImportMap is a short-lived intermediate data struture records, for+The ImportMap is a short-lived intermediate data structure records, for each import declaration, what stuff brought into scope by that declaration is actually used in the module. @@ -1240,7 +1252,7 @@ type ImportMap = Map SrcLoc [AvailInfo] -- See [The ImportMap] -findImportUsage :: [LImportDecl Name]+findImportUsage :: [LImportDecl GhcRn] -> [GlobalRdrElt] -> [ImportDeclUsage] @@ -1265,7 +1277,7 @@ foldr (add_unused . unLoc) emptyNameSet imp_ies _other -> emptyNameSet -- No explicit import list => no unused-name list - add_unused :: IE Name -> NameSet -> NameSet+ add_unused :: IE GhcRn -> NameSet -> NameSet add_unused (IEVar (L _ n)) acc = add_unused_name (ieWrappedName n) acc add_unused (IEThingAbs (L _ n)) acc@@ -1408,7 +1420,7 @@ where doc = text "Compute minimal imports for" <+> ppr decl - to_ie :: ModIface -> AvailInfo -> [IE Name]+ to_ie :: ModIface -> AvailInfo -> [IE GhcRn] -- The main trick here is that if we're importing all the constructors -- we want to say "T(..)", but if we're importing only a subset we want -- to say "T(A,B,C)". So we have to find out what the module exports.@@ -1507,7 +1519,7 @@ = hang (text "Illegal qualified name in import item:") 2 (ppr rdr) -badImportItemErrStd :: ModIface -> ImpDeclSpec -> IE RdrName -> SDoc+badImportItemErrStd :: ModIface -> ImpDeclSpec -> IE GhcPs -> SDoc badImportItemErrStd iface decl_spec ie = sep [text "Module", quotes (ppr (is_mod decl_spec)), source_import, text "does not export", quotes (ppr ie)]@@ -1515,7 +1527,8 @@ source_import | mi_boot iface = text "(hi-boot interface)" | otherwise = Outputable.empty -badImportItemErrDataCon :: OccName -> ModIface -> ImpDeclSpec -> IE RdrName -> SDoc+badImportItemErrDataCon :: OccName -> ModIface -> ImpDeclSpec -> IE GhcPs+ -> SDoc badImportItemErrDataCon dataType_occ iface decl_spec ie = vcat [ text "In module" <+> quotes (ppr (is_mod decl_spec))@@ -1540,7 +1553,7 @@ | otherwise = Outputable.empty parens_sp d = parens (space <> d <> space) -- T( f,g ) -badImportItemErr :: ModIface -> ImpDeclSpec -> IE RdrName -> [AvailInfo] -> SDoc+badImportItemErr :: ModIface -> ImpDeclSpec -> IE GhcPs -> [AvailInfo] -> SDoc badImportItemErr iface decl_spec ie avails = case find checkIfDataCon avails of Just con -> badImportItemErrDataCon (availOccName con) iface decl_spec ie@@ -1559,17 +1572,25 @@ illegalImportItemErr = text "Illegal import item" dodgyImportWarn :: RdrName -> SDoc-dodgyImportWarn item = dodgyMsg (text "import") item+dodgyImportWarn item+ = dodgyMsg (text "import") item (dodgyMsgInsert item :: IE GhcPs) -dodgyMsg :: (OutputableBndr n, HasOccName n) => SDoc -> n -> SDoc-dodgyMsg kind tc+dodgyMsg :: (Outputable a, Outputable b) => SDoc -> a -> b -> SDoc+dodgyMsg kind tc ie = sep [ text "The" <+> kind <+> ptext (sLit "item")- <+> quotes (ppr (IEThingAll (noLoc (IEName $ noLoc tc))))+ -- <+> quotes (ppr (IEThingAll (noLoc (IEName $ noLoc tc))))+ <+> quotes (ppr ie) <+> text "suggests that", quotes (ppr tc) <+> text "has (in-scope) constructors or class methods,", text "but it has none" ] +dodgyMsgInsert :: forall p . IdP p -> IE p+dodgyMsgInsert tc = IEThingAll ii+ where+ ii :: LIEWrappedName (IdP p)+ ii = noLoc (IEName $ noLoc tc) + addDupDeclErr :: [GlobalRdrElt] -> TcRn () addDupDeclErr [] = panic "addDupDeclErr: empty list" addDupDeclErr gres@(gre : _)@@ -1592,7 +1613,7 @@ missingImportListWarn mod = text "The module" <+> quotes (ppr mod) <+> ptext (sLit "does not have an explicit import list") -missingImportListItem :: IE RdrName -> SDoc+missingImportListItem :: IE GhcPs -> SDoc missingImportListItem ie = text "The import item" <+> quotes (ppr ie) <+> ptext (sLit "does not have an explicit import list")
rename/RnPat.hs view
@@ -35,6 +35,8 @@ -- ENH: thin imports to only what is necessary for patterns +import GhcPrelude+ import {-# SOURCE #-} RnExpr ( rnLExpr ) import {-# SOURCE #-} RnSplice ( rnSplicePat ) @@ -44,6 +46,12 @@ import TcRnMonad import TcHsSyn ( hsOverLitName ) import RnEnv+import RnFixity+import RnUtils ( HsDocContext(..), newLocalBndrRn, bindLocalNames+ , warnUnusedMatches, newLocalBndrRn+ , checkDupNames, checkDupAndShadowedNames+ , checkTupSize , unknownSubordinateErr )+import RnUnbound ( mkUnboundName ) import RnTypes import PrelNames import TyCon ( tyConName )@@ -51,6 +59,7 @@ import Type ( TyThing(..) ) import Name import NameSet+import OccName ( setOccNameSpace, tcName ) import RdrName import BasicTypes import Util@@ -62,7 +71,8 @@ import DataCon import qualified GHC.LanguageExtensions as LangExt -import Control.Monad ( when, liftM, ap, unless )+import Control.Monad ( when, liftM, ap )+import qualified Data.List.NonEmpty as NE import Data.Ratio {-@@ -205,7 +215,7 @@ ThPatQuote -> False _ -> True -rnHsSigCps :: LHsSigWcType RdrName -> CpsRn (LHsSigWcType Name)+rnHsSigCps :: LHsSigWcType GhcPs -> CpsRn (LHsSigWcType GhcRn) rnHsSigCps sig = CpsRn (rnHsSigWcTypeScoped PatCtx sig) newPatLName :: NameMaker -> Located RdrName -> CpsRn (Located Name)@@ -297,8 +307,8 @@ -- * unused and duplicate checking -- * no fixities rnPats :: HsMatchContext Name -- for error messages- -> [LPat RdrName]- -> ([LPat Name] -> RnM (a, FreeVars))+ -> [LPat GhcPs]+ -> ([LPat GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars) rnPats ctxt pats thing_inside = do { envs_before <- getRdrEnvs@@ -315,17 +325,18 @@ -- complain *twice* about duplicates e.g. f (x,x) = ... -- -- See note [Don't report shadowing for pattern synonyms]- ; unless (isPatSynCtxt ctxt)- (addErrCtxt doc_pat $- checkDupAndShadowedNames envs_before $- collectPatsBinders pats')+ ; let bndrs = collectPatsBinders pats'+ ; addErrCtxt doc_pat $+ if isPatSynCtxt ctxt+ then checkDupNames bndrs+ else checkDupAndShadowedNames envs_before bndrs ; thing_inside pats' } } where doc_pat = text "In" <+> pprMatchContext ctxt rnPat :: HsMatchContext Name -- for error messages- -> LPat RdrName- -> (LPat Name -> RnM (a, FreeVars))+ -> LPat GhcPs+ -> (LPat GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars) -- Variables bound by pattern do not -- appear in the result FreeVars rnPat ctxt pat thing_inside@@ -343,8 +354,8 @@ -- * no unused and duplicate checking -- * fixities might be coming in rnBindPat :: NameMaker- -> LPat RdrName- -> RnM (LPat Name, FreeVars)+ -> LPat GhcPs+ -> RnM (LPat GhcRn, FreeVars) -- Returned FreeVars are the free variables of the pattern, -- of course excluding variables bound by this pattern @@ -361,17 +372,17 @@ -- ----------- Entry point 3: rnLPatAndThen ------------------- -- General version: parametrized by how you make new names -rnLPatsAndThen :: NameMaker -> [LPat RdrName] -> CpsRn [LPat Name]+rnLPatsAndThen :: NameMaker -> [LPat GhcPs] -> CpsRn [LPat GhcRn] rnLPatsAndThen mk = mapM (rnLPatAndThen mk) -- Despite the map, the monad ensures that each pattern binds -- variables that may be mentioned in subsequent patterns in the list -------------------- -- The workhorse-rnLPatAndThen :: NameMaker -> LPat RdrName -> CpsRn (LPat Name)+rnLPatAndThen :: NameMaker -> LPat GhcPs -> CpsRn (LPat GhcRn) rnLPatAndThen nm lpat = wrapSrcSpanCps (rnPatAndThen nm) lpat -rnPatAndThen :: NameMaker -> Pat RdrName -> CpsRn (Pat Name)+rnPatAndThen :: NameMaker -> Pat GhcPs -> CpsRn (Pat GhcRn) rnPatAndThen _ (WildPat _) = return (WildPat placeHolderType) rnPatAndThen mk (ParPat pat) = do { pat' <- rnLPatAndThen mk pat; return (ParPat pat') } rnPatAndThen mk (LazyPat pat) = do { pat' <- rnLPatAndThen mk pat; return (LazyPat pat') }@@ -406,20 +417,28 @@ else normal_lit } | otherwise = normal_lit where- normal_lit = do { liftCps (rnLit lit); return (LitPat lit) }+ normal_lit = do { liftCps (rnLit lit); return (LitPat (convertLit lit)) } rnPatAndThen _ (NPat (L l lit) mb_neg _eq _)- = do { lit' <- liftCpsFV $ rnOverLit lit- ; mb_neg' <- liftCpsFV $ case mb_neg of- Nothing -> return (Nothing, emptyFVs)- Just _ -> do { (neg, fvs) <- lookupSyntaxName negateName- ; return (Just neg, fvs) }+ = do { (lit', mb_neg') <- liftCpsFV $ rnOverLit lit+ ; mb_neg' -- See Note [Negative zero]+ <- let negative = do { (neg, fvs) <- lookupSyntaxName negateName+ ; return (Just neg, fvs) }+ positive = return (Nothing, emptyFVs)+ in liftCpsFV $ case (mb_neg , mb_neg') of+ (Nothing, Just _ ) -> negative+ (Just _ , Nothing) -> negative+ (Nothing, Nothing) -> positive+ (Just _ , Just _ ) -> positive ; eq' <- liftCpsFV $ lookupSyntaxName eqName ; return (NPat (L l lit') mb_neg' eq' placeHolderType) } rnPatAndThen mk (NPlusKPat rdr (L l lit) _ _ _ _) = do { new_name <- newPatName mk rdr- ; lit' <- liftCpsFV $ rnOverLit lit+ ; (lit', _) <- liftCpsFV $ rnOverLit lit -- See Note [Negative zero]+ -- We skip negateName as+ -- negative zero doesn't make+ -- sense in n + k patterns ; minus <- liftCpsFV $ lookupSyntaxName minusName ; ge <- liftCpsFV $ lookupSyntaxName geName ; return (NPlusKPat (L (nameSrcSpan new_name) new_name)@@ -489,9 +508,9 @@ -------------------- rnConPatAndThen :: NameMaker- -> Located RdrName -- the constructor- -> HsConPatDetails RdrName- -> CpsRn (Pat Name)+ -> Located RdrName -- the constructor+ -> HsConPatDetails GhcPs+ -> CpsRn (Pat GhcRn) rnConPatAndThen mk con (PrefixCon pats) = do { con' <- lookupConCps con@@ -513,8 +532,8 @@ -------------------- rnHsRecPatsAndThen :: NameMaker -> Located Name -- Constructor- -> HsRecFields RdrName (LPat RdrName)- -> CpsRn (HsRecFields Name (LPat Name))+ -> HsRecFields GhcPs (LPat GhcPs)+ -> CpsRn (HsRecFields GhcRn (LPat GhcRn)) rnHsRecPatsAndThen mk (L _ con) hs_rec_fields@(HsRecFields { rec_dotdot = dd }) = do { flds <- liftCpsFV $ rnHsRecFields (HsRecFieldPat con) mkVarPat hs_rec_fields@@ -549,8 +568,8 @@ HsRecFieldContext -> (SrcSpan -> RdrName -> arg) -- When punning, use this to build a new field- -> HsRecFields RdrName (Located arg)- -> RnM ([LHsRecField Name (Located arg)], FreeVars)+ -> HsRecFields GhcPs (Located arg)+ -> RnM ([LHsRecField GhcRn (Located arg)], FreeVars) -- This surprisingly complicated pass -- a) looks up the field name (possibly using disambiguation)@@ -572,20 +591,16 @@ ; return (all_flds, mkFVs (getFieldIds all_flds)) } where mb_con = case ctxt of- HsRecFieldCon con | not (isUnboundName con) -> Just con- HsRecFieldPat con | not (isUnboundName con) -> Just con- _ {- update or isUnboundName con -} -> Nothing- -- The unbound name test is because if the constructor- -- isn't in scope the constructor lookup will add an error- -- add an error, but still return an unbound name.- -- We don't want that to screw up the dot-dot fill-in stuff.+ HsRecFieldCon con -> Just con+ HsRecFieldPat con -> Just con+ _ {- update -} -> Nothing doc = case mb_con of Nothing -> text "constructor field name" Just con -> text "field of constructor" <+> quotes (ppr con) - rn_fld :: Bool -> Maybe Name -> LHsRecField RdrName (Located arg)- -> RnM (LHsRecField Name (Located arg))+ rn_fld :: Bool -> Maybe Name -> LHsRecField GhcPs (Located arg)+ -> RnM (LHsRecField GhcRn (Located arg)) rn_fld pun_ok parent (L l (HsRecField { hsRecFieldLbl = L loc (FieldOcc (L ll lbl) _) , hsRecFieldArg = arg@@ -603,16 +618,16 @@ , hsRecPun = pun })) } rn_dotdot :: Maybe Int -- See Note [DotDot fields] in HsPat- -> Maybe Name -- The constructor (Nothing for an+ -> Maybe Name -- The constructor (Nothing for an -- out of scope constructor)- -> [LHsRecField Name (Located arg)] -- Explicit fields- -> RnM [LHsRecField Name (Located arg)] -- Filled in .. fields- rn_dotdot Nothing _mb_con _flds -- No ".." at all- = return []- rn_dotdot (Just {}) Nothing _flds -- Constructor out of scope- = return []+ -> [LHsRecField GhcRn (Located arg)] -- Explicit fields+ -> RnM [LHsRecField GhcRn (Located arg)] -- Filled in .. fields rn_dotdot (Just n) (Just con) flds -- ".." on record construction / pat match- = ASSERT( n == length flds )+ | not (isUnboundName con) -- This test is because if the constructor+ -- isn't in scope the constructor lookup will add+ -- an error but still return an unbound name. We+ -- don't want that to screw up the dot-dot fill-in stuff.+ = ASSERT( flds `lengthIs` n ) do { loc <- getSrcSpanM -- Rather approximate ; dd_flag <- xoptM LangExt.RecordWildCards ; checkErr dd_flag (needFlagDotDot ctxt)@@ -648,6 +663,12 @@ , let sel = flSelector fl , let arg_rdr = mkVarUnqual (flLabel fl) ] } + rn_dotdot _dotdot _mb_con _flds+ = return []+ -- _dotdot = Nothing => No ".." at all+ -- _mb_con = Nothing => Record update+ -- _mb_con = Just unbound => Out of scope data constructor+ check_disambiguation :: Bool -> Maybe Name -> RnM (Maybe Name) -- When disambiguation is on, return name of parent tycon. check_disambiguation disambig_ok mb_con@@ -655,12 +676,19 @@ = do { env <- getGlobalRdrEnv; return (find_tycon env con) } | otherwise = return Nothing - find_tycon :: GlobalRdrEnv -> Name {- DataCon -} -> Maybe Name {- TyCon -}+ find_tycon :: GlobalRdrEnv -> Name {- DataCon -}+ -> Maybe Name {- TyCon -} -- Return the parent *type constructor* of the data constructor -- (that is, the parent of the data constructor), -- or 'Nothing' if it is a pattern synonym or not in scope. -- That's the parent to use for looking up record fields. find_tycon env con_name+ | isUnboundName con_name+ = Just (mkUnboundName (setOccNameSpace tcName (getOccName con_name)))+ -- If the data con is not in scope, return an unboundName tycon+ -- That way the calls to lookupRecFieldOcc in rn_fld won't generate+ -- an error cascade; see Trac #14307+ | Just (AConLike (RealDataCon dc)) <- wiredInNameTyThing_maybe con_name = Just (tyConName (dataConTyCon dc)) -- Special case for [], which is built-in syntax@@ -676,7 +704,7 @@ -- Data constructor not lexically in scope at all -- See Note [Disambiguation and Template Haskell] - dup_flds :: [[RdrName]]+ dup_flds :: [NE.NonEmpty RdrName] -- Each list represents a RdrName that occurred more than once -- (the list contains all occurrences) -- Each list in dup_fields is non-empty@@ -700,8 +728,8 @@ -} rnHsRecUpdFields- :: [LHsRecUpdField RdrName]- -> RnM ([LHsRecUpdField Name], FreeVars)+ :: [LHsRecUpdField GhcPs]+ -> RnM ([LHsRecUpdField GhcRn], FreeVars) rnHsRecUpdFields flds = do { pun_ok <- xoptM LangExt.RecordPuns ; overload_ok <- xoptM LangExt.DuplicateRecordFields@@ -716,7 +744,8 @@ where doc = text "constructor field name" - rn_fld :: Bool -> Bool -> LHsRecUpdField RdrName -> RnM (LHsRecUpdField Name, FreeVars)+ rn_fld :: Bool -> Bool -> LHsRecUpdField GhcPs+ -> RnM (LHsRecUpdField GhcRn, FreeVars) rn_fld pun_ok overload_ok (L l (HsRecField { hsRecFieldLbl = L loc f , hsRecFieldArg = arg , hsRecPun = pun }))@@ -741,20 +770,20 @@ ; let fvs' = case sel of Left sel_name -> fvs `addOneFV` sel_name- Right [FieldOcc _ sel_name] -> fvs `addOneFV` sel_name+ Right [sel_name] -> fvs `addOneFV` sel_name Right _ -> fvs lbl' = case sel of Left sel_name -> L loc (Unambiguous (L loc lbl) sel_name)- Right [FieldOcc lbl sel_name] ->- L loc (Unambiguous lbl sel_name)+ Right [sel_name] ->+ L loc (Unambiguous (L loc lbl) sel_name) Right _ -> L loc (Ambiguous (L loc lbl) PlaceHolder) ; return (L l (HsRecField { hsRecFieldLbl = lbl' , hsRecFieldArg = arg'' , hsRecPun = pun }), fvs') } - dup_flds :: [[RdrName]]+ dup_flds :: [NE.NonEmpty RdrName] -- Each list represents a RdrName that occurred more than once -- (the list contains all occurrences) -- Each list in dup_fields is non-empty@@ -762,7 +791,7 @@ -getFieldIds :: [LHsRecField Name arg] -> [Name]+getFieldIds :: [LHsRecField GhcRn arg] -> [Name] getFieldIds flds = map (unLoc . hsRecFieldSel . unLoc) flds getFieldLbls :: [LHsRecField id arg] -> [RdrName]@@ -788,10 +817,10 @@ badPun fld = vcat [text "Illegal use of punning for field" <+> quotes (ppr fld), text "Use NamedFieldPuns to permit this"] -dupFieldErr :: HsRecFieldContext -> [RdrName] -> SDoc+dupFieldErr :: HsRecFieldContext -> NE.NonEmpty RdrName -> SDoc dupFieldErr ctxt dups = hsep [text "duplicate field name",- quotes (ppr (head dups)),+ quotes (ppr (NE.head dups)), text "in record", pprRFC ctxt] pprRFC :: HsRecFieldContext -> SDoc@@ -811,18 +840,38 @@ are made available. -} -rnLit :: HsLit -> RnM ()+rnLit :: HsLit p -> RnM () rnLit (HsChar _ c) = checkErr (inCharRange c) (bogusCharError c) rnLit _ = return () -- Turn a Fractional-looking literal which happens to be an integer into an -- Integer-looking literal. generalizeOverLitVal :: OverLitVal -> OverLitVal-generalizeOverLitVal (HsFractional (FL {fl_text=src,fl_value=val}))- | denominator val == 1 = HsIntegral (SourceText src) (numerator val)+generalizeOverLitVal (HsFractional (FL {fl_text=src,fl_neg=neg,fl_value=val}))+ | denominator val == 1 = HsIntegral (IL {il_text=src,il_neg=neg,il_value=numerator val}) generalizeOverLitVal lit = lit -rnOverLit :: HsOverLit t -> RnM (HsOverLit Name, FreeVars)+isNegativeZeroOverLit :: HsOverLit t -> Bool+isNegativeZeroOverLit lit+ = case ol_val lit of+ HsIntegral i -> 0 == il_value i && il_neg i+ HsFractional f -> 0 == fl_value f && fl_neg f+ _ -> False++{-+Note [Negative zero]+~~~~~~~~~~~~~~~~~~~~~~~~~+There were problems with negative zero in conjunction with Negative Literals+extension. Numeric literal value is contained in Integer and Rational types+inside IntegralLit and FractionalLit. These types cannot represent negative+zero value. So we had to add explicit field 'neg' which would hold information+about literal sign. Here in rnOverLit we use it to detect negative zeroes and+in this case return not only literal itself but also negateName so that users+can apply it explicitly. In this case it stays negative zero. Trac #13211+-}++rnOverLit :: HsOverLit t ->+ RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars) rnOverLit origLit = do { opt_NumDecimals <- xoptM LangExt.NumDecimals ; let { lit@(OverLit {ol_val=val})@@ -830,14 +879,20 @@ | otherwise = origLit } ; let std_name = hsOverLitName val- ; (SyntaxExpr { syn_expr = from_thing_name }, fvs)+ ; (SyntaxExpr { syn_expr = from_thing_name }, fvs1) <- lookupSyntaxName std_name ; let rebindable = case from_thing_name of HsVar (L _ v) -> v /= std_name _ -> panic "rnOverLit"- ; return (lit { ol_witness = from_thing_name- , ol_rebindable = rebindable- , ol_type = placeHolderType }, fvs) }+ ; let lit' = lit { ol_witness = from_thing_name+ , ol_rebindable = rebindable+ , ol_type = placeHolderType }+ ; if isNegativeZeroOverLit lit'+ then do { (SyntaxExpr { syn_expr = negate_name }, fvs2)+ <- lookupSyntaxName negateName+ ; return ((lit' { ol_val = negateOverLitVal val }, Just negate_name)+ , fvs1 `plusFV` fvs2) }+ else return ((lit', Nothing), fvs1) } {- ************************************************************************@@ -856,6 +911,6 @@ bogusCharError c = text "character literal out of range: '\\" <> char c <> char '\'' -badViewPat :: Pat RdrName -> SDoc+badViewPat :: Pat GhcPs -> SDoc badViewPat pat = vcat [text "Illegal view pattern: " <+> ppr pat, text "Use ViewPatterns to enable view patterns"]
rename/RnSource.hs view
@@ -5,6 +5,8 @@ -} {-# LANGUAGE CPP, ScopedTypeVariables #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-} module RnSource ( rnSrcDecls, addTcgDUs, findSplice@@ -12,6 +14,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} RnExpr( rnLExpr ) import {-# SOURCE #-} RnSplice ( rnSpliceDecl, rnTopSpliceDecls ) @@ -21,6 +25,11 @@ import RnTypes import RnBinds import RnEnv+import RnUtils ( HsDocContext(..), mapFvRn, bindLocalNames+ , checkDupRdrNames, inHsDocContext, bindLocalNamesFV+ , checkShadowedRdrNames, warnUnusedTypePatterns+ , extendTyVarEnvFVRn, newLocalBndrsRn )+import RnUnbound ( mkUnboundName ) import RnNames import RnHsDoc ( rnHsDoc, rnMbLHsDoc ) import TcAnnotations ( annCtxt )@@ -43,20 +52,23 @@ import Outputable import Bag import BasicTypes ( DerivStrategy, RuleName, pprRuleName )+import Maybes ( orElse ) import FastString import SrcLoc import DynFlags-import Util ( debugIsOn, lengthExceeds, partitionWith )+import Util ( debugIsOn, filterOut, lengthExceeds, partitionWith ) import HscTypes ( HscEnv, hsc_dflags ) import ListSetOps ( findDupsEq, removeDups, equivClasses )-import Digraph ( SCC, flattenSCC, flattenSCCs+import Digraph ( SCC, flattenSCC, flattenSCCs, Node(..) , stronglyConnCompFromEdgedVerticesUniq ) import UniqSet import qualified GHC.LanguageExtensions as LangExt import Control.Monad import Control.Arrow ( first )-import Data.List ( sortBy, mapAccumL )+import Data.List ( mapAccumL )+import qualified Data.List.NonEmpty as NE+import Data.List.NonEmpty ( NonEmpty(..) ) import Data.Maybe ( isJust ) import qualified Data.Set as Set ( difference, fromList, toList, null ) @@ -76,7 +88,7 @@ Brings the binders of the group into scope in the appropriate places; does NOT assume that anything is in scope already -}-rnSrcDecls :: HsGroup RdrName -> RnM (TcGblEnv, HsGroup Name)+rnSrcDecls :: HsGroup GhcPs -> RnM (TcGblEnv, HsGroup GhcRn) -- Rename a top-level HsGroup; used for normal source files *and* hs-boot files rnSrcDecls group@(HsGroup { hs_valds = val_decls, hs_splcds = splice_decls,@@ -131,7 +143,6 @@ -- They are already in scope traceRn "rnSrcDecls" (ppr id_bndrs) ; tc_envs <- extendGlobalRdrEnvRn (map avail id_bndrs) local_fix_env ;- traceRn "D2" (ppr (tcg_rdr_env (fst tc_envs))); setEnvs tc_envs $ do { -- Now everything is in scope, as the remaining renaming assumes.@@ -166,7 +177,8 @@ -- Rename fixity declarations and error if we try to -- fix something from another module (duplicates were checked in (A)) let { all_bndrs = tc_bndrs `unionNameSet` val_bndr_set } ;- rn_fix_decls <- rnSrcFixityDecls all_bndrs fix_decls ;+ rn_fix_decls <- mapM (mapM (rnSrcFixityDecl (TopSigCtxt all_bndrs)))+ fix_decls ; -- Rename deprec decls; -- check for duplicates and ensure that deprecated things are defined locally@@ -217,7 +229,6 @@ in -- we return the deprecs in the env, not in the HsGroup above tcg_env' { tcg_warns = tcg_warns tcg_env' `plusWarns` rn_warns }; } ;- traceRn "last" (ppr (tcg_rdr_env final_tcg_env)) ; traceRn "finish rnSrc" (ppr rn_group) ; traceRn "finish Dus" (ppr src_dus ) ; return (final_tcg_env, rn_group)@@ -256,45 +267,6 @@ {- ********************************************************* * *- Source-code fixity declarations-* *-*********************************************************--}--rnSrcFixityDecls :: NameSet -> [LFixitySig RdrName] -> RnM [LFixitySig Name]--- Rename the fixity decls, so we can put--- the renamed decls in the renamed syntax tree--- Errors if the thing being fixed is not defined locally.------ The returned FixitySigs are not actually used for anything,--- except perhaps the GHCi API-rnSrcFixityDecls bndr_set fix_decls- = do fix_decls <- mapM rn_decl fix_decls- return (concat fix_decls)- where- sig_ctxt = TopSigCtxt bndr_set-- rn_decl :: LFixitySig RdrName -> RnM [LFixitySig Name]- -- GHC extension: look up both the tycon and data con- -- for con-like things; hence returning a list- -- If neither are in scope, report an error; otherwise- -- return a fixity sig for each (slightly odd)- rn_decl (L loc (FixitySig fnames fixity))- = do names <- mapM lookup_one fnames- return [ L loc (FixitySig name fixity)- | name <- names ]-- lookup_one :: Located RdrName -> RnM [Located Name]- lookup_one (L name_loc rdr_name)- = setSrcSpan name_loc $- -- this lookup will fail if the definition isn't local- do names <- lookupLocalTcNames sig_ctxt what rdr_name- return [ L name_loc name | (_, name) <- names ]- what = text "fixity signature"--{--*********************************************************-* * Source-code deprecations declarations * * *********************************************************@@ -307,13 +279,13 @@ -} -- checks that the deprecations are defined locally, and that there are no duplicates-rnSrcWarnDecls :: NameSet -> [LWarnDecls RdrName] -> RnM Warnings+rnSrcWarnDecls :: NameSet -> [LWarnDecls GhcPs] -> RnM Warnings rnSrcWarnDecls _ [] = return NoWarnings rnSrcWarnDecls bndr_set decls' = do { -- check for duplicates- ; mapM_ (\ dups -> let (L loc rdr:lrdr':_) = dups+ ; mapM_ (\ dups -> let (L loc rdr :| (lrdr':_)) = dups in addErrAt loc (dupWarnDecl lrdr' rdr)) warn_rdr_dups ; pairs_s <- mapM (addLocM rn_deprec) decls@@ -334,7 +306,7 @@ warn_rdr_dups = findDupRdrNames $ concatMap (\(L _ (Warning ns _)) -> ns) decls -findDupRdrNames :: [Located RdrName] -> [[Located RdrName]]+findDupRdrNames :: [Located RdrName] -> [NonEmpty (Located RdrName)] findDupRdrNames = findDupsEq (\ x -> \ y -> rdrNameOcc (unLoc x) == rdrNameOcc (unLoc y)) -- look for duplicates among the OccNames;@@ -355,7 +327,7 @@ ********************************************************* -} -rnAnnDecl :: AnnDecl RdrName -> RnM (AnnDecl Name, FreeVars)+rnAnnDecl :: AnnDecl GhcPs -> RnM (AnnDecl GhcRn, FreeVars) rnAnnDecl ann@(HsAnnotation s provenance expr) = addErrCtxt (annCtxt ann) $ do { (provenance', provenance_fvs) <- rnAnnProvenance provenance@@ -364,7 +336,8 @@ ; return (HsAnnotation s provenance' expr', provenance_fvs `plusFV` expr_fvs) } -rnAnnProvenance :: AnnProvenance RdrName -> RnM (AnnProvenance Name, FreeVars)+rnAnnProvenance :: AnnProvenance RdrName+ -> RnM (AnnProvenance Name, FreeVars) rnAnnProvenance provenance = do provenance' <- traverse lookupTopBndrRn provenance return (provenance', maybe emptyFVs unitFV (annProvenanceName_maybe provenance'))@@ -377,7 +350,7 @@ ********************************************************* -} -rnDefaultDecl :: DefaultDecl RdrName -> RnM (DefaultDecl Name, FreeVars)+rnDefaultDecl :: DefaultDecl GhcPs -> RnM (DefaultDecl GhcRn, FreeVars) rnDefaultDecl (DefaultDecl tys) = do { (tys', fvs) <- rnLHsTypes doc_str tys ; return (DefaultDecl tys', fvs) }@@ -392,7 +365,7 @@ ********************************************************* -} -rnHsForeignDecl :: ForeignDecl RdrName -> RnM (ForeignDecl Name, FreeVars)+rnHsForeignDecl :: ForeignDecl GhcPs -> RnM (ForeignDecl GhcRn, FreeVars) rnHsForeignDecl (ForeignImport { fd_name = name, fd_sig_ty = ty, fd_fi = spec }) = do { topEnv :: HscEnv <- getTopEnv ; name' <- lookupLocatedTopBndrRn name@@ -447,7 +420,7 @@ ********************************************************* -} -rnSrcInstDecl :: InstDecl RdrName -> RnM (InstDecl Name, FreeVars)+rnSrcInstDecl :: InstDecl GhcPs -> RnM (InstDecl GhcRn, FreeVars) rnSrcInstDecl (TyFamInstD { tfid_inst = tfi }) = do { (tfi', fvs) <- rnTyFamInstDecl Nothing tfi ; return (TyFamInstD { tfid_inst = tfi' }, fvs) }@@ -457,7 +430,9 @@ ; return (DataFamInstD { dfid_inst = dfi' }, fvs) } rnSrcInstDecl (ClsInstD { cid_inst = cid })- = do { (cid', fvs) <- rnClsInstDecl cid+ = do { traceRn "rnSrcIstDecl {" (ppr cid)+ ; (cid', fvs) <- rnClsInstDecl cid+ ; traceRn "rnSrcIstDecl end }" empty ; return (ClsInstD { cid_inst = cid' }, fvs) } -- | Warn about non-canonical typeclass instance declarations@@ -472,7 +447,7 @@ -- -- See also descriptions of 'checkCanonicalMonadInstances' and -- 'checkCanonicalMonoidInstances'-checkCanonicalInstances :: Name -> LHsSigType Name -> LHsBinds Name -> RnM ()+checkCanonicalInstances :: Name -> LHsSigType GhcRn -> LHsBinds GhcRn -> RnM () checkCanonicalInstances cls poly_ty mbinds = do whenWOptM Opt_WarnNonCanonicalMonadInstances checkCanonicalMonadInstances@@ -603,7 +578,7 @@ -- | test whether MatchGroup represents a trivial \"lhsName = rhsName\" -- binding, and return @Just rhsName@ if this is the case- isAliasMG :: MatchGroup Name (LHsExpr Name) -> Maybe Name+ isAliasMG :: MatchGroup GhcRn (LHsExpr GhcRn) -> Maybe Name isAliasMG MG {mg_alts = L _ [L _ (Match { m_pats = [], m_grhss = grhss })]} | GRHSs [L _ (GRHS [] body)] lbinds <- grhss , L _ EmptyLocalBinds <- lbinds@@ -646,7 +621,7 @@ ] -- stolen from TcInstDcls- instDeclCtxt1 :: LHsSigType Name -> SDoc+ instDeclCtxt1 :: LHsSigType GhcRn -> SDoc instDeclCtxt1 hs_inst_ty = inst_decl_ctxt (ppr (getLHsInstDeclHead hs_inst_ty)) @@ -655,7 +630,7 @@ 2 (quotes doc <> text ".") -rnClsInstDecl :: ClsInstDecl RdrName -> RnM (ClsInstDecl Name, FreeVars)+rnClsInstDecl :: ClsInstDecl GhcPs -> RnM (ClsInstDecl GhcRn, FreeVars) rnClsInstDecl (ClsInstDecl { cid_poly_ty = inst_ty, cid_binds = mbinds , cid_sigs = uprags, cid_tyfam_insts = ats , cid_overlap_mode = oflag@@ -704,44 +679,54 @@ -- strange, but should not matter (and it would be more work -- to remove the context). -rnFamInstDecl :: HsDocContext- -> Maybe (Name, [Name]) -- Nothing => not associated- -- Just (cls,tvs) => associated,- -- and gives class and tyvars of the- -- parent instance delc- -> Located RdrName- -> HsTyPats RdrName- -> rhs- -> (HsDocContext -> rhs -> RnM (rhs', FreeVars))- -> RnM (Located Name, HsTyPats Name, rhs', FreeVars)-rnFamInstDecl doc mb_cls tycon (HsIB { hsib_body = pats }) payload rnPayload+rnFamInstEqn :: HsDocContext+ -> Maybe (Name, [Name]) -- Nothing => not associated+ -- Just (cls,tvs) => associated,+ -- and gives class and tyvars of the+ -- parent instance delc+ -> [Located RdrName] -- Kind variables from the equation's RHS+ -> FamInstEqn GhcPs rhs+ -> (HsDocContext -> rhs -> RnM (rhs', FreeVars))+ -> RnM (FamInstEqn GhcRn rhs', FreeVars)+rnFamInstEqn doc mb_cls rhs_kvars+ (HsIB { hsib_body = FamEqn { feqn_tycon = tycon+ , feqn_pats = pats+ , feqn_fixity = fixity+ , feqn_rhs = payload }}) rn_payload = do { tycon' <- lookupFamInstName (fmap fst mb_cls) tycon ; let loc = case pats of- [] -> pprPanic "rnFamInstDecl" (ppr tycon)+ [] -> pprPanic "rnFamInstEqn" (ppr tycon) (L loc _ : []) -> loc (L loc _ : ps) -> combineSrcSpans loc (getLoc (last ps)) ; pat_kity_vars_with_dups <- extractHsTysRdrTyVarsDups pats+ ; let pat_vars = freeKiTyVarsAllVars $+ rmDupsInRdrTyVars pat_kity_vars_with_dups -- Use the "...Dups" form because it's needed -- below to report unsed binder on the LHS- ; var_names <- mapM (newTyVarNameRn mb_cls . L loc . unLoc) $- freeKiTyVarsAllVars $- rmDupsInRdrTyVars pat_kity_vars_with_dups+ ; pat_var_names <- mapM (newTyVarNameRn mb_cls . L loc . unLoc) pat_vars + -- Make sure to filter out the kind variables that were explicitly+ -- bound in the type patterns.+ ; let payload_vars = filterOut (`elemRdr` pat_vars) rhs_kvars+ ; payload_var_names <- mapM (newTyVarNameRn mb_cls) payload_vars++ ; let all_var_names = pat_var_names ++ payload_var_names+ -- All the free vars of the family patterns -- with a sensible binding location ; ((pats', payload'), fvs)- <- bindLocalNamesFV var_names $+ <- bindLocalNamesFV all_var_names $ do { (pats', pat_fvs) <- rnLHsTypes (FamPatCtx tycon) pats- ; (payload', rhs_fvs) <- rnPayload doc payload+ ; (payload', rhs_fvs) <- rn_payload doc payload -- Report unused binders on the LHS -- See Note [Unused type variables in family instances]- ; let groups :: [[Located RdrName]]+ ; let groups :: [NonEmpty (Located RdrName)] groups = equivClasses cmpLocated $ freeKiTyVarsAllVars pat_kity_vars_with_dups ; tv_nms_dups <- mapM (lookupOccRn . unLoc) $- [ tv | (tv:_:_) <- groups ]+ [ tv | (tv :| (_:_)) <- groups ] -- Add to the used variables -- a) any variables that appear *more than once* on the LHS -- e.g. F a Int a = Bool@@ -753,13 +738,13 @@ inst_tvs = case mb_cls of Nothing -> [] Just (_, inst_tvs) -> inst_tvs- ; warnUnusedTypePatterns var_names tv_nms_used+ ; warnUnusedTypePatterns pat_var_names tv_nms_used -- See Note [Renaming associated types] ; let bad_tvs = case mb_cls of Nothing -> [] Just (_,cls_tkvs) -> filter is_bad cls_tkvs- var_name_set = mkNameSet var_names+ var_name_set = mkNameSet all_var_names is_bad cls_tkv = cls_tkv `elemNameSet` rhs_fvs && not (cls_tkv `elemNameSet` var_name_set)@@ -768,91 +753,83 @@ ; return ((pats', payload'), rhs_fvs `plusFV` pat_fvs) } ; let anon_wcs = concatMap collectAnonWildCards pats'- all_ibs = anon_wcs ++ var_names+ all_ibs = anon_wcs ++ all_var_names -- all_ibs: include anonymous wildcards in the implicit -- binders In a type pattern they behave just like any -- other type variable except for being anoymous. See -- Note [Wildcards in family instances] all_fvs = fvs `addOneFV` unLoc tycon'+ -- type instance => use, hence addOneFV - ; return (tycon',- HsIB { hsib_body = pats'- , hsib_vars = all_ibs- , hsib_closed = True },- payload',+ ; return (HsIB { hsib_vars = all_ibs+ , hsib_closed = True+ , hsib_body+ = FamEqn { feqn_tycon = tycon'+ , feqn_pats = pats'+ , feqn_fixity = fixity+ , feqn_rhs = payload' } }, all_fvs) }- -- type instance => use, hence addOneFV rnTyFamInstDecl :: Maybe (Name, [Name])- -> TyFamInstDecl RdrName- -> RnM (TyFamInstDecl Name, FreeVars)-rnTyFamInstDecl mb_cls (TyFamInstDecl { tfid_eqn = L loc eqn })+ -> TyFamInstDecl GhcPs+ -> RnM (TyFamInstDecl GhcRn, FreeVars)+rnTyFamInstDecl mb_cls (TyFamInstDecl { tfid_eqn = eqn }) = do { (eqn', fvs) <- rnTyFamInstEqn mb_cls eqn- ; return (TyFamInstDecl { tfid_eqn = L loc eqn'- , tfid_fvs = fvs }, fvs) }+ ; return (TyFamInstDecl { tfid_eqn = eqn' }, fvs) } rnTyFamInstEqn :: Maybe (Name, [Name])- -> TyFamInstEqn RdrName- -> RnM (TyFamInstEqn Name, FreeVars)-rnTyFamInstEqn mb_cls (TyFamEqn { tfe_tycon = tycon- , tfe_pats = pats- , tfe_fixity = fixity- , tfe_rhs = rhs })- = do { (tycon', pats', rhs', fvs) <-- rnFamInstDecl (TySynCtx tycon) mb_cls tycon pats rhs rnTySyn- ; return (TyFamEqn { tfe_tycon = tycon'- , tfe_pats = pats'- , tfe_fixity = fixity- , tfe_rhs = rhs' }, fvs) }+ -> TyFamInstEqn GhcPs+ -> RnM (TyFamInstEqn GhcRn, FreeVars)+rnTyFamInstEqn mb_cls eqn@(HsIB { hsib_body = FamEqn { feqn_tycon = tycon+ , feqn_rhs = rhs }})+ = do { rhs_kvs <- extractHsTyRdrTyVarsKindVars rhs+ ; rnFamInstEqn (TySynCtx tycon) mb_cls rhs_kvs eqn rnTySyn } rnTyFamDefltEqn :: Name- -> TyFamDefltEqn RdrName- -> RnM (TyFamDefltEqn Name, FreeVars)-rnTyFamDefltEqn cls (TyFamEqn { tfe_tycon = tycon- , tfe_pats = tyvars- , tfe_fixity = fixity- , tfe_rhs = rhs })- = bindHsQTyVars ctx Nothing (Just cls) [] tyvars $ \ tyvars' _ ->+ -> TyFamDefltEqn GhcPs+ -> RnM (TyFamDefltEqn GhcRn, FreeVars)+rnTyFamDefltEqn cls (FamEqn { feqn_tycon = tycon+ , feqn_pats = tyvars+ , feqn_fixity = fixity+ , feqn_rhs = rhs })+ = do { kvs <- extractHsTyRdrTyVarsKindVars rhs+ ; bindHsQTyVars ctx Nothing (Just cls) kvs tyvars $ \ tyvars' _ -> do { tycon' <- lookupFamInstName (Just cls) tycon ; (rhs', fvs) <- rnLHsType ctx rhs- ; return (TyFamEqn { tfe_tycon = tycon'- , tfe_pats = tyvars'- , tfe_fixity = fixity- , tfe_rhs = rhs' }, fvs) }+ ; return (FamEqn { feqn_tycon = tycon'+ , feqn_pats = tyvars'+ , feqn_fixity = fixity+ , feqn_rhs = rhs' }, fvs) } } where ctx = TyFamilyCtx tycon rnDataFamInstDecl :: Maybe (Name, [Name])- -> DataFamInstDecl RdrName- -> RnM (DataFamInstDecl Name, FreeVars)-rnDataFamInstDecl mb_cls (DataFamInstDecl { dfid_tycon = tycon- , dfid_pats = pats- , dfid_fixity = fixity- , dfid_defn = defn })- = do { (tycon', pats', (defn', _), fvs) <-- rnFamInstDecl (TyDataCtx tycon) mb_cls tycon pats defn rnDataDefn- ; return (DataFamInstDecl { dfid_tycon = tycon'- , dfid_pats = pats'- , dfid_fixity = fixity- , dfid_defn = defn'- , dfid_fvs = fvs }, fvs) }+ -> DataFamInstDecl GhcPs+ -> RnM (DataFamInstDecl GhcRn, FreeVars)+rnDataFamInstDecl mb_cls (DataFamInstDecl { dfid_eqn = eqn@(HsIB { hsib_body =+ FamEqn { feqn_tycon = tycon+ , feqn_rhs = rhs }})})+ = do { rhs_kvs <- extractDataDefnKindVars rhs+ ; (eqn', fvs) <-+ rnFamInstEqn (TyDataCtx tycon) mb_cls rhs_kvs eqn rnDataDefn+ ; return (DataFamInstDecl { dfid_eqn = eqn' }, fvs) } -- Renaming of the associated types in instances. -- Rename associated type family decl in class rnATDecls :: Name -- Class- -> [LFamilyDecl RdrName]- -> RnM ([LFamilyDecl Name], FreeVars)+ -> [LFamilyDecl GhcPs]+ -> RnM ([LFamilyDecl GhcRn], FreeVars) rnATDecls cls at_decls = rnList (rnFamDecl (Just cls)) at_decls -rnATInstDecls :: (Maybe (Name, [Name]) -> -- The function that renames- decl RdrName -> -- an instance. rnTyFamInstDecl- RnM (decl Name, FreeVars)) -- or rnDataFamInstDecl+rnATInstDecls :: (Maybe (Name, [Name]) -> -- The function that renames+ decl GhcPs -> -- an instance. rnTyFamInstDecl+ RnM (decl GhcRn, FreeVars)) -- or rnDataFamInstDecl -> Name -- Class -> [Name]- -> [Located (decl RdrName)]- -> RnM ([Located (decl Name)], FreeVars)+ -> [Located (decl GhcPs)]+ -> RnM ([Located (decl GhcRn)], FreeVars) -- Used for data and type family defaults in a class decl -- and the family instance declarations in an instance --@@ -878,7 +855,7 @@ This is implemented as follows: during renaming anonymous wild cards '_' are given freshly generated names. These names are collected after-renaming (rnFamInstDecl) and used to make new type variables during+renaming (rnFamInstEqn) and used to make new type variables during type checking (tc_fam_ty_pats). One should not confuse these wild cards with the ones from partial type signatures. The latter generate fresh meta-variables whereas the former generate fresh skolems.@@ -914,7 +891,7 @@ Note [Renaming associated types] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Check that the RHS of the decl mentions only type variables+Check that the RHS of the decl mentions only type variables that are explicitly bound on the LHS. For example, this is not ok class C a b where type F a x :: *@@ -922,13 +899,26 @@ type F (p,q) x = (x, r) -- BAD: mentions 'r' c.f. Trac #5515 -The same thing applies to kind variables, of course (Trac #7938, #9574):+Kind variables, on the other hand, are allowed to be implicitly or explicitly+bound. As examples, this (#9574) is acceptable: class Funct f where type Codomain f :: * instance Funct ('KProxy :: KProxy o) where+ -- o is implicitly bound by the kind signature+ -- of the LHS type pattern ('KProxy) type Codomain 'KProxy = NatTr (Proxy :: o -> *)-Here 'o' is mentioned on the RHS of the Codomain function, but-not on the LHS.+And this (#14131) is also acceptable:+ data family Nat :: k -> k -> *+ -- k is implicitly bound by an invisible kind pattern+ newtype instance Nat :: (k -> *) -> (k -> *) -> * where+ Nat :: (forall xx. f xx -> g xx) -> Nat f g+We could choose to disallow this, but then associated type families would not+be able to be as expressive as top-level type synonyms. For example, this type+synonym definition is allowed:+ type T = (Nothing :: Maybe a)+So for parity with type synonyms, we also allow:+ type family T :: Maybe a+ type instance T = (Nothing :: Maybe a) All this applies only for *instance* declarations. In *class* declarations there is no RHS to worry about, and the class variables@@ -949,14 +939,14 @@ ********************************************************* -} -rnSrcDerivDecl :: DerivDecl RdrName -> RnM (DerivDecl Name, FreeVars)+rnSrcDerivDecl :: DerivDecl GhcPs -> RnM (DerivDecl GhcRn, FreeVars) rnSrcDerivDecl (DerivDecl ty deriv_strat overlap) = do { standalone_deriv_ok <- xoptM LangExt.StandaloneDeriving ; deriv_strats_ok <- xoptM LangExt.DerivingStrategies ; unless standalone_deriv_ok (addErr standaloneDerivErr) ; failIfTc (isJust deriv_strat && not deriv_strats_ok) $ illegalDerivStrategyErr $ fmap unLoc deriv_strat- ; (ty', fvs) <- rnLHsInstType (text "In a deriving declaration") ty+ ; (ty', fvs) <- rnLHsInstType (text "a deriving declaration") ty ; return (DerivDecl ty' deriv_strat overlap, fvs) } standaloneDerivErr :: SDoc@@ -972,12 +962,12 @@ ********************************************************* -} -rnHsRuleDecls :: RuleDecls RdrName -> RnM (RuleDecls Name, FreeVars)+rnHsRuleDecls :: RuleDecls GhcPs -> RnM (RuleDecls GhcRn, FreeVars) rnHsRuleDecls (HsRules src rules) = do { (rn_rules,fvs) <- rnList rnHsRuleDecl rules ; return (HsRules src rn_rules,fvs) } -rnHsRuleDecl :: RuleDecl RdrName -> RnM (RuleDecl Name, FreeVars)+rnHsRuleDecl :: RuleDecl GhcPs -> RnM (RuleDecl GhcRn, FreeVars) rnHsRuleDecl (HsRule rule_name act vars lhs _fv_lhs rhs _fv_rhs) = do { let rdr_names_w_loc = map get_var vars ; checkDupRdrNames rdr_names_w_loc@@ -993,8 +983,8 @@ get_var (L _ (RuleBndrSig v _)) = v get_var (L _ (RuleBndr v)) = v -bindHsRuleVars :: RuleName -> [LRuleBndr RdrName] -> [Name]- -> ([LRuleBndr Name] -> RnM (a, FreeVars))+bindHsRuleVars :: RuleName -> [LRuleBndr GhcPs] -> [Name]+ -> ([LRuleBndr GhcRn] -> RnM (a, FreeVars)) -> RnM (a, FreeVars) bindHsRuleVars rule_name vars names thing_inside = go vars names $ \ vars' ->@@ -1030,7 +1020,7 @@ check_e is commented out. -} -checkValidRule :: FastString -> [Name] -> LHsExpr Name -> NameSet -> RnM ()+checkValidRule :: FastString -> [Name] -> LHsExpr GhcRn -> NameSet -> RnM () checkValidRule rule_name ids lhs' fv_lhs' = do { -- Check for the form of the LHS case (validRuleLhs ids lhs') of@@ -1041,7 +1031,7 @@ ; let bad_vars = [var | var <- ids, not (var `elemNameSet` fv_lhs')] ; mapM_ (addErr . badRuleVar rule_name) bad_vars } -validRuleLhs :: [Name] -> LHsExpr Name -> Maybe (HsExpr Name)+validRuleLhs :: [Name] -> LHsExpr GhcRn -> Maybe (HsExpr GhcRn) -- Nothing => OK -- Just e => Not ok, and e is the offending sub-expression validRuleLhs foralls lhs@@ -1079,7 +1069,7 @@ text "Forall'd variable" <+> quotes (ppr var) <+> text "does not appear on left hand side"] -badRuleLhsErr :: FastString -> LHsExpr Name -> HsExpr Name -> SDoc+badRuleLhsErr :: FastString -> LHsExpr GhcRn -> HsExpr GhcRn -> SDoc badRuleLhsErr name lhs bad_e = sep [text "Rule" <+> pprRuleName name <> colon, nest 4 (vcat [err,@@ -1099,7 +1089,7 @@ ********************************************************* -} -rnHsVectDecl :: VectDecl RdrName -> RnM (VectDecl Name, FreeVars)+rnHsVectDecl :: VectDecl GhcPs -> RnM (VectDecl GhcRn, FreeVars) -- FIXME: For the moment, the right-hand side is restricted to be a variable as we cannot properly -- typecheck a complex right-hand side without invoking 'vectType' from the vectoriser. rnHsVectDecl (HsVect s var rhs@(L _ (HsVar _)))@@ -1281,8 +1271,8 @@ -} -rnTyClDecls :: [TyClGroup RdrName]- -> RnM ([TyClGroup Name], FreeVars)+rnTyClDecls :: [TyClGroup GhcPs]+ -> RnM ([TyClGroup GhcRn], FreeVars) -- Rename the declarations and do dependency analysis on them rnTyClDecls tycl_ds = do { -- Rename the type/class, instance, and role declaraations@@ -1293,9 +1283,6 @@ ; instds_w_fvs <- mapM (wrapLocFstM rnSrcInstDecl) (tyClGroupInstDecls tycl_ds) ; role_annots <- rnRoleAnnots tc_names (tyClGroupRoleDecls tycl_ds) - ; tycls_w_fvs <- addBootDeps tycls_w_fvs- -- TBD must add_boot_deps to instds_w_fvs?- -- Do SCC analysis on the type/class decls ; rdr_env <- getGlobalRdrEnv ; let tycl_sccs = depAnalTyClDecls rdr_env tycls_w_fvs@@ -1327,9 +1314,9 @@ ; return (all_groups, all_fvs) } where mk_group :: (InstDeclFreeVarsMap, RoleAnnotEnv)- -> SCC (LTyClDecl Name)+ -> SCC (LTyClDecl GhcRn) -> ( (InstDeclFreeVarsMap, RoleAnnotEnv)- , TyClGroup Name )+ , TyClGroup GhcRn ) mk_group (inst_map, role_env) scc = ((inst_map', role_env'), group) where@@ -1343,13 +1330,14 @@ depAnalTyClDecls :: GlobalRdrEnv- -> [(LTyClDecl Name, FreeVars)]- -> [SCC (LTyClDecl Name)]+ -> [(LTyClDecl GhcRn, FreeVars)]+ -> [SCC (LTyClDecl GhcRn)] -- See Note [Dependency analysis of type, class, and instance decls] depAnalTyClDecls rdr_env ds_w_fvs = stronglyConnCompFromEdgedVerticesUniq edges where- edges = [ (d, tcdName (unLoc d), map (getParent rdr_env) (nonDetEltsUniqSet fvs))+ edges :: [ Node Name (LTyClDecl GhcRn) ]+ edges = [ DigraphNode d (tcdName (unLoc d)) (map (getParent rdr_env) (nonDetEltsUniqSet fvs)) | (d, fvs) <- ds_w_fvs ] -- It's OK to use nonDetEltsUFM here as -- stronglyConnCompFromEdgedVertices is still deterministic@@ -1374,120 +1362,6 @@ Nothing -> n -{- Note [Extra dependencies from .hs-boot files]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-This is a long story, so buckle in.--**Dependencies via hs-boot files are not obvious.** Consider the following case:--A.hs-boot- module A where- data A1--B.hs- module B where- import {-# SOURCE #-} A- type B1 = A1--A.hs- module A where- import B- data A2 = MkA2 B1- data A1 = MkA1 A2--Here A2 is really recursive (via B1), but we won't see that easily when-doing dependency analysis when compiling A.hs. When we look at A2,-we see that its free variables are simply B1, but without (recursively) digging-into the definition of B1 will we see that it actually refers to A1 via an-hs-boot file.--**Recursive declarations, even those broken by an hs-boot file, need to-be type-checked together.** Whenever we refer to a declaration via-an hs-boot file, we must be careful not to force the TyThing too early:-ala Note [Tying the knot] if we force the TyThing before we have-defined it ourselves in the local type environment, GHC will error.--Conservatively, then, it would make sense that we to typecheck A1-and A2 from the previous example together, because the two types are-truly mutually recursive through B1.--If we are being clever, we might observe that while kind-checking-A2, we don't actually need to force the TyThing for A1: B1-independently records its kind, so there is no need to go "deeper".-But then we are in an uncomfortable situation where we have-constructed a TyThing for A2 before we have checked A1, and we-have to be absolutely certain we don't force it too deeply until-we get around to kind checking A1, which could be for a very long-time.--Indeed, with datatype promotion, we may very well need to look-at the type of MkA2 before we have kind-checked A1: consider,-- data T = MkT (Proxy 'MkA2)--To promote MkA2, we need to lift its type to the kind level.-We never tested this, but it seems likely A1 would get poked-at this point.--**Here's what we do instead.** So it is expedient for us to-make sure A1 and A2 are kind checked together in a loop.-To ensure that our dependency analysis can catch this,-we add a dependency:-- - from every local declaration- - to everything that comes from this module's .hs-boot file- (this is gotten from sb_tcs in the SelfBootInfo).--In this case, we'll add an edges-- - from A1 to A2 (but that edge is there already)- - from A2 to A1 (which is new)--Well, not quite *every* declaration. Imagine module A-above had another datatype declaration:-- data A3 = A3 Int--Even though A3 has a dependency (on Int), all its dependencies are from things-that live on other packages. Since we don't have mutual dependencies across-packages, it is safe not to add the dependencies on the .hs-boot stuff to A2.--Hence function nameIsHomePackageImport.--Note that this is fairly conservative: it essentially implies that-EVERY type declaration in this modules hs-boot file will be kind-checked-together in one giant loop (and furthermore makes every other type-in the module depend on this loop). This is perhaps less than ideal, because-the larger a recursive group, the less polymorphism available (we-cannot infer a type to be polymorphically instantiated while we-are inferring its kind), but no one has hollered about this (yet!)--}--addBootDeps :: [(LTyClDecl Name, FreeVars)] -> RnM [(LTyClDecl Name, FreeVars)]--- See Note [Extra dependencies from .hs-boot files]-addBootDeps ds_w_fvs- = do { tcg_env <- getGblEnv- ; let this_mod = tcg_mod tcg_env- boot_info = tcg_self_boot tcg_env-- add_boot_deps :: [(LTyClDecl Name, FreeVars)] -> [(LTyClDecl Name, FreeVars)]- add_boot_deps ds_w_fvs- = case boot_info of- SelfBoot { sb_tcs = tcs } | not (isEmptyNameSet tcs)- -> map (add_one tcs) ds_w_fvs- _ -> ds_w_fvs-- add_one :: NameSet -> (LTyClDecl Name, FreeVars) -> (LTyClDecl Name, FreeVars)- add_one tcs pr@(decl,fvs)- | has_local_imports fvs = (decl, fvs `plusFV` tcs)- | otherwise = pr-- has_local_imports fvs- = nameSetAny (nameIsHomePackageImport this_mod) fvs- ; return (add_boot_deps ds_w_fvs) }--- {- ****************************************************** * * Role annotations@@ -1499,8 +1373,8 @@ -- It is quite convenient to do both of these in the same place. -- See also Note [Role annotations in the renamer] rnRoleAnnots :: NameSet- -> [LRoleAnnotDecl RdrName]- -> RnM [LRoleAnnotDecl Name]+ -> [LRoleAnnotDecl GhcPs]+ -> RnM [LRoleAnnotDecl GhcRn] rnRoleAnnots tc_names role_annots = do { -- Check for duplicates *before* renaming, to avoid -- lumping together all the unboundNames@@ -1518,23 +1392,22 @@ tycon ; return $ RoleAnnotDecl tycon' roles } -dupRoleAnnotErr :: [LRoleAnnotDecl RdrName] -> RnM ()-dupRoleAnnotErr [] = panic "dupRoleAnnotErr"+dupRoleAnnotErr :: NonEmpty (LRoleAnnotDecl GhcPs) -> RnM () dupRoleAnnotErr list = addErrAt loc $ hang (text "Duplicate role annotations for" <+> quotes (ppr $ roleAnnotDeclName first_decl) <> colon)- 2 (vcat $ map pp_role_annot sorted_list)+ 2 (vcat $ map pp_role_annot $ NE.toList sorted_list) where- sorted_list = sortBy cmp_annot list- (L loc first_decl : _) = sorted_list+ sorted_list = NE.sortBy cmp_annot list+ (L loc first_decl :| _) = sorted_list pp_role_annot (L loc decl) = hang (ppr decl) 4 (text "-- written at" <+> ppr loc) cmp_annot (L loc1 _) (L loc2 _) = loc1 `compare` loc2 -orphanRoleAnnotErr :: LRoleAnnotDecl Name -> RnM ()+orphanRoleAnnotErr :: LRoleAnnotDecl GhcRn -> RnM () orphanRoleAnnotErr (L loc decl) = addErrAt loc $ hang (text "Role annotation for a type previously declared:")@@ -1588,13 +1461,13 @@ -- the tycon names that are both -- a) free in the instance declaration -- b) bound by this group of type/class/instance decls-type InstDeclFreeVarsMap = [(LInstDecl Name, FreeVars)]+type InstDeclFreeVarsMap = [(LInstDecl GhcRn, FreeVars)] -- | Construct an @InstDeclFreeVarsMap@ by eliminating any @Name@s from the -- @FreeVars@ which are *not* the binders of a @TyClDecl@. mkInstDeclFreeVarsMap :: GlobalRdrEnv -> NameSet- -> [(LInstDecl Name, FreeVars)]+ -> [(LInstDecl GhcRn, FreeVars)] -> InstDeclFreeVarsMap mkInstDeclFreeVarsMap rdr_env tycl_bndrs inst_ds_fvs = [ (inst_decl, toParents rdr_env fvs `intersectFVs` tycl_bndrs)@@ -1608,12 +1481,13 @@ -- whose free vars are now defined -- instd_map' is the inst-decl map with 'tcs' removed from -- the free-var set-getInsts :: [Name] -> InstDeclFreeVarsMap -> ([LInstDecl Name], InstDeclFreeVarsMap)+getInsts :: [Name] -> InstDeclFreeVarsMap+ -> ([LInstDecl GhcRn], InstDeclFreeVarsMap) getInsts bndrs inst_decl_map = partitionWith pick_me inst_decl_map where- pick_me :: (LInstDecl Name, FreeVars)- -> Either (LInstDecl Name) (LInstDecl Name, FreeVars)+ pick_me :: (LInstDecl GhcRn, FreeVars)+ -> Either (LInstDecl GhcRn) (LInstDecl GhcRn, FreeVars) pick_me (decl, fvs) | isEmptyNameSet depleted_fvs = Left decl | otherwise = Right (decl, depleted_fvs)@@ -1626,8 +1500,8 @@ * * ****************************************************** -} -rnTyClDecl :: TyClDecl RdrName- -> RnM (TyClDecl Name, FreeVars)+rnTyClDecl :: TyClDecl GhcPs+ -> RnM (TyClDecl GhcRn, FreeVars) -- All flavours of type family declarations ("type family", "newtype family", -- and "data family"), both top level and (for an associated type)@@ -1639,16 +1513,14 @@ rnTyClDecl (SynDecl { tcdLName = tycon, tcdTyVars = tyvars, tcdFixity = fixity, tcdRhs = rhs }) = do { tycon' <- lookupLocatedTopBndrRn tycon- ; kvs <- freeKiTyVarsKindVars <$> extractHsTyRdrTyVars rhs+ ; kvs <- extractHsTyRdrTyVarsKindVars rhs ; let doc = TySynCtx tycon ; traceRn "rntycl-ty" (ppr tycon <+> ppr kvs)- ; ((tyvars', rhs'), fvs) <- bindHsQTyVars doc Nothing Nothing kvs tyvars $- \ tyvars' _ ->- do { (rhs', fvs) <- rnTySyn doc rhs- ; return ((tyvars', rhs'), fvs) }+ ; bindHsQTyVars doc Nothing Nothing kvs tyvars $ \ tyvars' _ ->+ do { (rhs', fvs) <- rnTySyn doc rhs ; return (SynDecl { tcdLName = tycon', tcdTyVars = tyvars' , tcdFixity = fixity- , tcdRhs = rhs', tcdFVs = fvs }, fvs) }+ , tcdRhs = rhs', tcdFVs = fvs }, fvs) } } -- "data", "newtype" declarations -- both top level and (for an associated type) in an instance decl@@ -1658,20 +1530,16 @@ ; kvs <- extractDataDefnKindVars defn ; let doc = TyDataCtx tycon ; traceRn "rntycl-data" (ppr tycon <+> ppr kvs)- ; ((tyvars', defn', no_kvs), fvs)- <- bindHsQTyVars doc Nothing Nothing kvs tyvars $ \ tyvars' dep_vars ->- do { ((defn', kind_sig_fvs), fvs) <- rnDataDefn doc defn- ; let sig_tvs = filterNameSet isTyVarName kind_sig_fvs- unbound_sig_tvs = sig_tvs `minusNameSet` dep_vars- ; return ((tyvars', defn', isEmptyNameSet unbound_sig_tvs), fvs) }+ ; bindHsQTyVars doc Nothing Nothing kvs tyvars $ \ tyvars' no_rhs_kvs ->+ do { (defn', fvs) <- rnDataDefn doc defn -- See Note [Complete user-supplied kind signatures] in HsDecls ; typeintype <- xoptM LangExt.TypeInType ; let cusk = hsTvbAllKinded tyvars' &&- (not typeintype || no_kvs)+ (not typeintype || no_rhs_kvs) ; return (DataDecl { tcdLName = tycon', tcdTyVars = tyvars' , tcdFixity = fixity , tcdDataDefn = defn', tcdDataCusk = cusk- , tcdFVs = fvs }, fvs) }+ , tcdFVs = fvs }, fvs) } } rnTyClDecl (ClassDecl { tcdCtxt = context, tcdLName = lcls, tcdTyVars = tyvars, tcdFixity = fixity,@@ -1738,13 +1606,11 @@ cls_doc = ClassDeclCtx lcls -- "type" and "type instance" declarations-rnTySyn :: HsDocContext -> LHsType RdrName -> RnM (LHsType Name, FreeVars)+rnTySyn :: HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars) rnTySyn doc rhs = rnLHsType doc rhs -rnDataDefn :: HsDocContext -> HsDataDefn RdrName- -> RnM ((HsDataDefn Name, NameSet), FreeVars)- -- the NameSet includes all Names free in the kind signature- -- See Note [Complete user-supplied kind signatures]+rnDataDefn :: HsDocContext -> HsDataDefn GhcPs+ -> RnM (HsDataDefn GhcRn, FreeVars) rnDataDefn doc (HsDataDefn { dd_ND = new_or_data, dd_cType = cType , dd_ctxt = context, dd_cons = condecls , dd_kindSig = m_sig, dd_derivs = derivs })@@ -1769,11 +1635,10 @@ ; let all_fvs = fvs1 `plusFV` fvs3 `plusFV` con_fvs `plusFV` sig_fvs- ; return (( HsDataDefn { dd_ND = new_or_data, dd_cType = cType- , dd_ctxt = context', dd_kindSig = m_sig'- , dd_cons = condecls'- , dd_derivs = derivs' }- , sig_fvs )+ ; return ( HsDataDefn { dd_ND = new_or_data, dd_cType = cType+ , dd_ctxt = context', dd_kindSig = m_sig'+ , dd_cons = condecls'+ , dd_derivs = derivs' } , all_fvs ) } where@@ -1788,8 +1653,8 @@ ; (ds', fvs) <- mapFvRn (rnLHsDerivingClause deriv_strats_ok doc) ds ; return (L loc ds', fvs) } -rnLHsDerivingClause :: Bool -> HsDocContext -> LHsDerivingClause RdrName- -> RnM (LHsDerivingClause Name, FreeVars)+rnLHsDerivingClause :: Bool -> HsDocContext -> LHsDerivingClause GhcPs+ -> RnM (LHsDerivingClause GhcRn, FreeVars) rnLHsDerivingClause deriv_strats_ok doc (L loc (HsDerivingClause { deriv_clause_strategy = dcs , deriv_clause_tys = L loc' dct }))@@ -1818,8 +1683,8 @@ rnFamDecl :: Maybe Name -- Just cls => this FamilyDecl is nested -- inside an *class decl* for cls -- used for associated types- -> FamilyDecl RdrName- -> RnM (FamilyDecl Name, FreeVars)+ -> FamilyDecl GhcPs+ -> RnM (FamilyDecl GhcRn, FreeVars) rnFamDecl mb_cls (FamilyDecl { fdLName = tycon, fdTyVars = tyvars , fdFixity = fixity , fdInfo = info, fdResultSig = res_sig@@ -1827,9 +1692,8 @@ = do { tycon' <- lookupLocatedTopBndrRn tycon ; kvs <- extractRdrKindSigVars res_sig ; ((tyvars', res_sig', injectivity'), fv1) <-- bindHsQTyVars doc Nothing mb_cls kvs tyvars $- \ tyvars'@(HsQTvs { hsq_implicit = rn_kvs }) _ ->- do { let rn_sig = rnFamResultSig doc rn_kvs+ bindHsQTyVars doc Nothing mb_cls kvs tyvars $ \ tyvars' _ ->+ do { let rn_sig = rnFamResultSig doc ; (res_sig', fv_kind) <- wrapLocFstM rn_sig res_sig ; injectivity' <- traverse (rnInjectivityAnn tyvars' res_sig') injectivity@@ -1854,15 +1718,14 @@ rn_info DataFamily = return (DataFamily, emptyFVs) rnFamResultSig :: HsDocContext- -> [Name] -- kind variables already in scope- -> FamilyResultSig RdrName- -> RnM (FamilyResultSig Name, FreeVars)-rnFamResultSig _ _ NoSig+ -> FamilyResultSig GhcPs+ -> RnM (FamilyResultSig GhcRn, FreeVars)+rnFamResultSig _ NoSig = return (NoSig, emptyFVs)-rnFamResultSig doc _ (KindSig kind)+rnFamResultSig doc (KindSig kind) = do { (rndKind, ftvs) <- rnLHsKind doc kind ; return (KindSig rndKind, ftvs) }-rnFamResultSig doc kv_names (TyVarSig tvbndr)+rnFamResultSig doc (TyVarSig tvbndr) = do { -- `TyVarSig` tells us that user named the result of a type family by -- writing `= tyvar` or `= (tyvar :: kind)`. In such case we want to -- be sure that the supplied result name is not identical to an@@ -1880,12 +1743,9 @@ ] $$ text "shadows an already bound type variable") - ; bindLHsTyVarBndr doc Nothing -- this might be a lie, but it's used for+ ; bindLHsTyVarBndr doc Nothing -- This might be a lie, but it's used for -- scoping checks that are irrelevant here- (mkNameSet kv_names) emptyNameSet- -- use of emptyNameSet here avoids- -- redundant duplicate errors- tvbndr $ \ _ _ tvbndr' ->+ tvbndr $ \ tvbndr' -> return (TyVarSig tvbndr', unitFV (hsLTyVarName tvbndr')) } -- Note [Renaming injectivity annotation]@@ -1922,11 +1782,11 @@ -- | Rename injectivity annotation. Note that injectivity annotation is just the -- part after the "|". Everything that appears before it is renamed in -- rnFamDecl.-rnInjectivityAnn :: LHsQTyVars Name -- ^ Type variables declared in+rnInjectivityAnn :: LHsQTyVars GhcRn -- ^ Type variables declared in -- type family head- -> LFamilyResultSig Name -- ^ Result signature- -> LInjectivityAnn RdrName -- ^ Injectivity annotation- -> RnM (LInjectivityAnn Name)+ -> LFamilyResultSig GhcRn -- ^ Result signature+ -> LInjectivityAnn GhcPs -- ^ Injectivity annotation+ -> RnM (LInjectivityAnn GhcRn) rnInjectivityAnn tvBndrs (L _ (TyVarSig resTv)) (L srcSpan (InjectivityAnn injFrom injTo)) = do@@ -2003,24 +1863,29 @@ badAssocRhs :: [Name] -> RnM () badAssocRhs ns = addErr (hang (text "The RHS of an associated type declaration mentions"+ <+> text "out-of-scope variable" <> plural ns <+> pprWithCommas (quotes . ppr) ns) 2 (text "All such variables must be bound on the LHS")) ------------------rnConDecls :: [LConDecl RdrName] -> RnM ([LConDecl Name], FreeVars)+rnConDecls :: [LConDecl GhcPs] -> RnM ([LConDecl GhcRn], FreeVars) rnConDecls = mapFvRn (wrapLocFstM rnConDecl) -rnConDecl :: ConDecl RdrName -> RnM (ConDecl Name, FreeVars)+rnConDecl :: ConDecl GhcPs -> RnM (ConDecl GhcRn, FreeVars) rnConDecl decl@(ConDeclH98 { con_name = name, con_qvars = qtvs , con_cxt = mcxt, con_details = details , con_doc = mb_doc }) = do { _ <- addLocM checkConName name ; new_name <- lookupLocatedTopBndrRn name- ; let doc = ConDeclCtx [new_name] ; mb_doc' <- rnMbLHsDoc mb_doc- ; (kvs, qtvs') <- get_con_qtvs (hsConDeclArgTys details) - ; bindHsQTyVars doc (Just $ inHsDocContext doc) Nothing kvs qtvs' $+ ; let doc = ConDeclCtx [new_name]+ qtvs' = qtvs `orElse` mkHsQTvs []+ body_kvs = [] -- Consider data T a = forall (b::k). MkT (...)+ -- The 'k' will already be in scope from the+ -- bindHsQTyVars for the entire DataDecl+ -- So there can be no new body_kvs here+ ; bindHsQTyVars doc (Just $ inHsDocContext doc) Nothing body_kvs qtvs' $ \new_tyvars _ -> do { (new_context, fvs1) <- case mcxt of Nothing -> return (Nothing,emptyFVs)@@ -2029,8 +1894,7 @@ ; (new_details, fvs2) <- rnConDeclDetails (unLoc new_name) doc details ; let (new_details',fvs3) = (new_details,emptyFVs) ; traceRn "rnConDecl" (ppr name <+> vcat- [ text "free_kvs:" <+> ppr kvs- , text "qtvs:" <+> ppr qtvs+ [ text "qtvs:" <+> ppr qtvs , text "qtvs':" <+> ppr qtvs' ]) ; let all_fvs = fvs1 `plusFV` fvs2 `plusFV` fvs3 new_tyvars' = case qtvs of@@ -2040,19 +1904,7 @@ , con_cxt = new_context, con_details = new_details' , con_doc = mb_doc' }, all_fvs) }}- where- cxt = maybe [] unLoc mcxt- get_rdr_tvs tys = extractHsTysRdrTyVars (cxt ++ tys) - get_con_qtvs :: [LHsType RdrName]- -> RnM ([Located RdrName], LHsQTyVars RdrName)- get_con_qtvs arg_tys- | Just tvs <- qtvs -- data T = forall a. MkT (a -> a)- = do { free_vars <- get_rdr_tvs arg_tys- ; return (freeKiTyVarsKindVars free_vars, tvs) }- | otherwise -- data T = MkT (a -> a)- = return ([], mkHsQTvs [])- rnConDecl decl@(ConDeclGADT { con_names = names, con_type = ty , con_doc = mb_doc }) = do { mapM_ (addLocM checkConName) names@@ -2070,8 +1922,9 @@ rnConDeclDetails :: Name -> HsDocContext- -> HsConDetails (LHsType RdrName) (Located [LConDeclField RdrName])- -> RnM (HsConDetails (LHsType Name) (Located [LConDeclField Name]), FreeVars)+ -> HsConDetails (LHsType GhcPs) (Located [LConDeclField GhcPs])+ -> RnM (HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]),+ FreeVars) rnConDeclDetails _ doc (PrefixCon tys) = do { (new_tys, fvs) <- rnLHsTypes doc tys ; return (PrefixCon new_tys, fvs) }@@ -2092,7 +1945,7 @@ -- | Brings pattern synonym names and also pattern synonym selectors -- from record pattern synonyms into scope.-extendPatSynEnv :: HsValBinds RdrName -> MiniFixityEnv+extendPatSynEnv :: HsValBinds GhcPs -> MiniFixityEnv -> ([Name] -> TcRnIf TcGblEnv TcLclEnv a) -> TcM a extendPatSynEnv val_decls local_fix_env thing = do { names_with_fls <- new_ps val_decls@@ -2105,20 +1958,20 @@ final_gbl_env = gbl_env { tcg_field_env = field_env' } ; setEnvs (final_gbl_env, lcl_env) (thing pat_syn_bndrs) } where- new_ps :: HsValBinds RdrName -> TcM [(Name, [FieldLabel])]+ new_ps :: HsValBinds GhcPs -> TcM [(Name, [FieldLabel])] new_ps (ValBindsIn binds _) = foldrBagM new_ps' [] binds new_ps _ = panic "new_ps" - new_ps' :: LHsBindLR RdrName RdrName+ new_ps' :: LHsBindLR GhcPs GhcPs -> [(Name, [FieldLabel])] -> TcM [(Name, [FieldLabel])] new_ps' bind names | L bind_loc (PatSynBind (PSB { psb_id = L _ n- , psb_args = RecordPatSyn as })) <- bind+ , psb_args = RecCon as })) <- bind = do bnd_name <- newTopSrcBinder (L bind_loc n) let rnames = map recordPatSynSelectorId as- mkFieldOcc :: Located RdrName -> LFieldOcc RdrName+ mkFieldOcc :: Located RdrName -> LFieldOcc GhcPs mkFieldOcc (L l name) = L l (FieldOcc (L l name) PlaceHolder) field_occs = map mkFieldOcc rnames flds <- mapM (newRecordSelector False [bnd_name]) field_occs@@ -2169,18 +2022,19 @@ b) runs any top-level quasi-quotes -} -findSplice :: [LHsDecl RdrName] -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))+findSplice :: [LHsDecl GhcPs]+ -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs])) findSplice ds = addl emptyRdrGroup ds -addl :: HsGroup RdrName -> [LHsDecl RdrName]- -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))+addl :: HsGroup GhcPs -> [LHsDecl GhcPs]+ -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs])) -- This stuff reverses the declarations (again) but it doesn't matter addl gp [] = return (gp, Nothing) addl gp (L l d : ds) = add gp l d ds -add :: HsGroup RdrName -> SrcSpan -> HsDecl RdrName -> [LHsDecl RdrName]- -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))+add :: HsGroup GhcPs -> SrcSpan -> HsDecl GhcPs -> [LHsDecl GhcPs]+ -> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs])) -- #10047: Declaration QuasiQuoters are expanded immediately, without -- causing a group split
rename/RnSplice.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module RnSplice ( rnTopSpliceDecls,@@ -10,6 +11,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Name import NameSet import HsSyn@@ -18,6 +21,8 @@ import Kind import RnEnv+import RnUtils ( HsDocContext(..), newLocalBndrRn )+import RnUnbound ( isUnboundName ) import RnSource ( rnSrcDecls, findSplice ) import RnPat ( rnPat ) import BasicTypes ( TopLevelFlag, isTopLevel, SourceText(..) )@@ -38,7 +43,6 @@ import ErrUtils ( dumpIfSet_dyn_printer ) import TcEnv ( tcMetaTy ) import Hooks-import Var ( Id ) import THNames ( quoteExpName, quotePatName, quoteDecName, quoteTypeName , decsQTyConName, expQTyConName, patQTyConName, typeQTyConName, ) @@ -65,7 +69,7 @@ ************************************************************************ -} -rnBracket :: HsExpr RdrName -> HsBracket RdrName -> RnM (HsExpr Name, FreeVars)+rnBracket :: HsExpr GhcPs -> HsBracket GhcPs -> RnM (HsExpr GhcRn, FreeVars) rnBracket e br_body = addErrCtxt (quotationCtxtDoc br_body) $ do { -- Check that -XTemplateHaskellQuotes is enabled and available@@ -110,7 +114,7 @@ ; return (HsRnBracketOut body' pendings, fvs_e) } } -rn_bracket :: ThStage -> HsBracket RdrName -> RnM (HsBracket Name, FreeVars)+rn_bracket :: ThStage -> HsBracket GhcPs -> RnM (HsBracket GhcRn, FreeVars) rn_bracket outer_stage br@(VarBr flg rdr_name) = do { name <- lookupOccRn rdr_name ; this_mod <- getModule@@ -157,7 +161,7 @@ ppr (duUses (tcg_dus tcg_env))) ; return (DecBrG group', duUses (tcg_dus tcg_env)) } where- groupDecls :: [LHsDecl RdrName] -> RnM (HsGroup RdrName)+ groupDecls :: [LHsDecl GhcPs] -> RnM (HsGroup GhcPs) groupDecls decls = do { (group, mb_splice) <- findSplice decls ; case mb_splice of@@ -174,7 +178,7 @@ rn_bracket _ (TExpBr e) = do { (e', fvs) <- rnLExpr e ; return (TExpBr e', fvs) } -quotationCtxtDoc :: HsBracket RdrName -> SDoc+quotationCtxtDoc :: HsBracket GhcPs -> SDoc quotationCtxtDoc br_body = hang (text "In the Template Haskell quotation") 2 (ppr br_body)@@ -192,7 +196,7 @@ illegalUntypedBracket = text "Untyped brackets may only appear in untyped splices." -quotedNameStageErr :: HsBracket RdrName -> SDoc+quotedNameStageErr :: HsBracket GhcPs -> SDoc quotedNameStageErr br = sep [ text "Stage error: the non-top-level quoted name" <+> ppr br , text "must be used at the same stage at which it is bound" ]@@ -234,9 +238,11 @@ We don't want the type checker to see these bogus unbound variables. -} -rnSpliceGen :: (HsSplice Name -> RnM (a, FreeVars)) -- Outside brackets, run splice- -> (HsSplice Name -> (PendingRnSplice, a)) -- Inside brackets, make it pending- -> HsSplice RdrName+rnSpliceGen :: (HsSplice GhcRn -> RnM (a, FreeVars))+ -- Outside brackets, run splice+ -> (HsSplice GhcRn -> (PendingRnSplice, a))+ -- Inside brackets, make it pending+ -> HsSplice GhcPs -> RnM (a, FreeVars) rnSpliceGen run_splice pend_splice splice = addErrCtxt (spliceCtxt splice) $ do@@ -279,10 +285,10 @@ -- -- See Note [Delaying modFinalizers in untyped splices]. runRnSplice :: UntypedSpliceFlavour- -> (LHsExpr Id -> TcRn res)+ -> (LHsExpr GhcTc -> TcRn res) -> (res -> SDoc) -- How to pretty-print res -- Usually just ppr, but not for [Decl]- -> HsSplice Name -- Always untyped+ -> HsSplice GhcRn -- Always untyped -> TcRn (res, [ForeignRef (TH.Q ())]) runRnSplice flavour run_meta ppr_res splice = do { splice' <- getHooked runRnSpliceHook return >>= ($ splice)@@ -327,7 +333,7 @@ ------------------ makePending :: UntypedSpliceFlavour- -> HsSplice Name+ -> HsSplice GhcRn -> PendingRnSplice makePending flavour (HsUntypedSplice _ n e) = PendingRnSplice flavour n e@@ -339,7 +345,8 @@ = pprPanic "makePending" (ppr splice) -------------------mkQuasiQuoteExpr :: UntypedSpliceFlavour -> Name -> SrcSpan -> FastString -> LHsExpr Name+mkQuasiQuoteExpr :: UntypedSpliceFlavour -> Name -> SrcSpan -> FastString+ -> LHsExpr GhcRn -- Return the expression (quoter "...quote...") -- which is what we must run in a quasi-quote mkQuasiQuoteExpr flavour quoter q_span quote@@ -357,7 +364,7 @@ UntypedDeclSplice -> quoteDecName ----------------------rnSplice :: HsSplice RdrName -> RnM (HsSplice Name, FreeVars)+rnSplice :: HsSplice GhcPs -> RnM (HsSplice GhcRn, FreeVars) -- Not exported...used for all rnSplice (HsTypedSplice hasParen splice_name expr) = do { checkTH expr "Template Haskell typed splice"@@ -389,15 +396,15 @@ rnSplice splice@(HsSpliced {}) = pprPanic "rnSplice" (ppr splice) ----------------------rnSpliceExpr :: HsSplice RdrName -> RnM (HsExpr Name, FreeVars)+rnSpliceExpr :: HsSplice GhcPs -> RnM (HsExpr GhcRn, FreeVars) rnSpliceExpr splice = rnSpliceGen run_expr_splice pend_expr_splice splice where- pend_expr_splice :: HsSplice Name -> (PendingRnSplice, HsExpr Name)+ pend_expr_splice :: HsSplice GhcRn -> (PendingRnSplice, HsExpr GhcRn) pend_expr_splice rn_splice = (makePending UntypedExpSplice rn_splice, HsSpliceE rn_splice) - run_expr_splice :: HsSplice Name -> RnM (HsExpr Name, FreeVars)+ run_expr_splice :: HsSplice GhcRn -> RnM (HsExpr GhcRn, FreeVars) run_expr_splice rn_splice | isTypedSplice rn_splice -- Run it later, in the type checker = do { -- Ugh! See Note [Splices] above@@ -514,8 +521,8 @@ -} -----------------------rnSpliceType :: HsSplice RdrName -> PostTc Name Kind- -> RnM (HsType Name, FreeVars)+rnSpliceType :: HsSplice GhcPs -> PostTc GhcRn Kind+ -> RnM (HsType GhcRn, FreeVars) rnSpliceType splice k = rnSpliceGen run_type_splice pend_type_splice splice where@@ -581,7 +588,7 @@ ---------------------- -- | Rename a splice pattern. See Note [rnSplicePat]-rnSplicePat :: HsSplice RdrName -> RnM ( Either (Pat RdrName) (Pat Name)+rnSplicePat :: HsSplice GhcPs -> RnM ( Either (Pat GhcPs) (Pat GhcRn) , FreeVars) rnSplicePat splice = rnSpliceGen run_pat_splice pend_pat_splice splice@@ -604,7 +611,7 @@ -- lose the outermost location set by runQuasiQuote (#7918) -----------------------rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)+rnSpliceDecl :: SpliceDecl GhcPs -> RnM (SpliceDecl GhcRn, FreeVars) rnSpliceDecl (SpliceDecl (L loc splice) flg) = rnSpliceGen run_decl_splice pend_decl_splice splice where@@ -613,7 +620,7 @@ run_decl_splice rn_splice = pprPanic "rnSpliceDecl" (ppr rn_splice) -rnTopSpliceDecls :: HsSplice RdrName -> RnM ([LHsDecl RdrName], FreeVars)+rnTopSpliceDecls :: HsSplice GhcPs -> RnM ([LHsDecl GhcPs], FreeVars) -- Declaration splice at the very top level of the module rnTopSpliceDecls splice = do { (rn_splice, fvs) <- checkNoErrs $@@ -627,7 +634,7 @@ ; add_mod_finalizers_now mod_finalizers ; return (decls,fvs) } where- ppr_decls :: [LHsDecl RdrName] -> SDoc+ ppr_decls :: [LHsDecl GhcPs] -> SDoc ppr_decls ds = vcat (map ppr ds) -- Adds finalizers to the global environment instead of delaying them@@ -671,7 +678,7 @@ rnSplicePat. -} -spliceCtxt :: HsSplice RdrName -> SDoc+spliceCtxt :: HsSplice GhcPs -> SDoc spliceCtxt splice = hang (text "In the" <+> what) 2 (ppr splice) where@@ -684,12 +691,12 @@ -- | The splice data to be logged data SpliceInfo = SpliceInfo- { spliceDescription :: String- , spliceSource :: Maybe (LHsExpr Name) -- Nothing <=> top-level decls- -- added by addTopDecls- , spliceIsDecl :: Bool -- True <=> put the generate code in a file- -- when -dth-dec-file is on- , spliceGenerated :: SDoc+ { spliceDescription :: String+ , spliceSource :: Maybe (LHsExpr GhcRn) -- Nothing <=> top-level decls+ -- added by addTopDecls+ , spliceIsDecl :: Bool -- True <=> put the generate code in a file+ -- when -dth-dec-file is on+ , spliceGenerated :: SDoc } -- Note that 'spliceSource' is *renamed* but not *typechecked* -- Reason (a) less typechecking crap
rename/RnSplice.hs-boot view
@@ -1,17 +1,16 @@ module RnSplice where +import GhcPrelude import HsSyn import TcRnMonad-import RdrName-import Name import NameSet import Kind -rnSpliceType :: HsSplice RdrName -> PostTc Name Kind- -> RnM (HsType Name, FreeVars)-rnSplicePat :: HsSplice RdrName -> RnM ( Either (Pat RdrName) (Pat Name)+rnSpliceType :: HsSplice GhcPs -> PostTc GhcRn Kind+ -> RnM (HsType GhcRn, FreeVars)+rnSplicePat :: HsSplice GhcPs -> RnM ( Either (Pat GhcPs) (Pat GhcRn) , FreeVars )-rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)+rnSpliceDecl :: SpliceDecl GhcPs -> RnM (SpliceDecl GhcRn, FreeVars) -rnTopSpliceDecls :: HsSplice RdrName -> RnM ([LHsDecl RdrName], FreeVars)+rnTopSpliceDecls :: HsSplice GhcPs -> RnM ([LHsDecl GhcPs], FreeVars)
rename/RnTypes.hs view
@@ -25,19 +25,29 @@ -- Binding related stuff bindLHsTyVarBndr, bindSigTyVarsFV, bindHsQTyVars, bindLRdrNames,- extractFilteredRdrTyVars,- extractHsTyRdrTyVars, extractHsTysRdrTyVars,+ extractFilteredRdrTyVars, extractFilteredRdrTyVarsDups,+ extractHsTyRdrTyVars, extractHsTyRdrTyVarsKindVars,+ extractHsTyRdrTyVarsDups, extractHsTysRdrTyVars, extractHsTysRdrTyVarsDups, rmDupsInRdrTyVars, extractRdrKindSigVars, extractDataDefnKindVars,- freeKiTyVarsAllVars, freeKiTyVarsKindVars, freeKiTyVarsTypeVars+ freeKiTyVarsAllVars, freeKiTyVarsKindVars, freeKiTyVarsTypeVars,+ elemRdr ) where +import GhcPrelude+ import {-# SOURCE #-} RnSplice( rnSpliceType ) import DynFlags import HsSyn import RnHsDoc ( rnLHsDoc, rnMbLHsDoc ) import RnEnv+import RnUnbound ( perhapsForallMsg )+import RnUtils ( HsDocContext(..), withHsDocContext, mapFvRn+ , pprHsDocContext, bindLocalNamesFV+ , newLocalBndrRn, checkDupRdrNames, checkShadowedRdrNames )+import RnFixity ( lookupFieldFixityRn, lookupFixityRn+ , lookupTyFixityRn ) import TcRnMonad import RdrName import PrelNames@@ -56,8 +66,8 @@ import Maybes import qualified GHC.LanguageExtensions as LangExt -import Data.List ( nubBy, partition )-import Control.Monad ( unless, when )+import Data.List ( nubBy, partition )+import Control.Monad ( unless, when ) #include "HsVersions.h" @@ -72,14 +82,14 @@ ********************************************************* -} -rnHsSigWcType :: HsDocContext -> LHsSigWcType RdrName- -> RnM (LHsSigWcType Name, FreeVars)+rnHsSigWcType :: HsDocContext -> LHsSigWcType GhcPs+ -> RnM (LHsSigWcType GhcRn, FreeVars) rnHsSigWcType doc sig_ty = rn_hs_sig_wc_type True doc sig_ty $ \sig_ty' -> return (sig_ty', emptyFVs) -rnHsSigWcTypeScoped :: HsDocContext -> LHsSigWcType RdrName- -> (LHsSigWcType Name -> RnM (a, FreeVars))+rnHsSigWcTypeScoped :: HsDocContext -> LHsSigWcType GhcPs+ -> (LHsSigWcType GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars) -- Used for -- - Signatures on binders in a RULE@@ -98,23 +108,24 @@ rn_hs_sig_wc_type :: Bool -- see rnImplicitBndrs -> HsDocContext- -> LHsSigWcType RdrName- -> (LHsSigWcType Name -> RnM (a, FreeVars))+ -> LHsSigWcType GhcPs+ -> (LHsSigWcType GhcRn -> RnM (a, FreeVars)) -> RnM (a, FreeVars) -- rn_hs_sig_wc_type is used for source-language type signatures rn_hs_sig_wc_type no_implicit_if_forall ctxt (HsWC { hswc_body = HsIB { hsib_body = hs_ty }}) thing_inside- = do { free_vars <- extractFilteredRdrTyVars hs_ty- ; (tv_rdrs, nwc_rdrs) <- partition_nwcs free_vars- ; rnImplicitBndrs no_implicit_if_forall tv_rdrs hs_ty $ \ vars ->+ = do { free_vars <- extractFilteredRdrTyVarsDups hs_ty+ ; (tv_rdrs, nwc_rdrs') <- partition_nwcs free_vars+ ; let nwc_rdrs = nubL nwc_rdrs'+ ; rnImplicitBndrs no_implicit_if_forall ctxt hs_ty tv_rdrs $ \ vars -> do { (wcs, hs_ty', fvs1) <- rnWcBody ctxt nwc_rdrs hs_ty ; let sig_ty' = HsWC { hswc_wcs = wcs, hswc_body = ib_ty' } ib_ty' = mk_implicit_bndrs vars hs_ty' fvs1 ; (res, fvs2) <- thing_inside sig_ty' ; return (res, fvs1 `plusFV` fvs2) } } -rnHsWcType :: HsDocContext -> LHsWcType RdrName -> RnM (LHsWcType Name, FreeVars)+rnHsWcType :: HsDocContext -> LHsWcType GhcPs -> RnM (LHsWcType GhcRn, FreeVars) rnHsWcType ctxt (HsWC { hswc_body = hs_ty }) = do { free_vars <- extractFilteredRdrTyVars hs_ty ; (_, nwc_rdrs) <- partition_nwcs free_vars@@ -122,8 +133,8 @@ ; let sig_ty' = HsWC { hswc_wcs = wcs, hswc_body = hs_ty' } ; return (sig_ty', fvs) } -rnWcBody :: HsDocContext -> [Located RdrName] -> LHsType RdrName- -> RnM ([Name], LHsType Name, FreeVars)+rnWcBody :: HsDocContext -> [Located RdrName] -> LHsType GhcPs+ -> RnM ([Name], LHsType GhcRn, FreeVars) rnWcBody ctxt nwc_rdrs hs_ty = do { nwcs <- mapM newLocalBndrRn nwc_rdrs ; let env = RTKE { rtke_level = TypeLevel@@ -140,11 +151,10 @@ do { (hs_ty', fvs) <- rn_ty env hs_ty ; return (L loc hs_ty', fvs) } - rn_ty :: RnTyKiEnv -> HsType RdrName -> RnM (HsType Name, FreeVars)+ rn_ty :: RnTyKiEnv -> HsType GhcPs -> RnM (HsType GhcRn, FreeVars) -- A lot of faff just to allow the extra-constraints wildcard to appear rn_ty env hs_ty@(HsForAllTy { hst_bndrs = tvs, hst_body = hs_body })- = bindLHsTyVarBndrs (rtke_ctxt env) (Just $ inTypeDoc hs_ty)- Nothing [] tvs $ \ _ tvs' _ _ ->+ = bindLHsTyVarBndrs (rtke_ctxt env) (Just $ inTypeDoc hs_ty) Nothing tvs $ \ tvs' -> do { (hs_body', fvs) <- rn_lty env hs_body ; return (HsForAllTy { hst_bndrs = tvs', hst_body = hs_body' }, fvs) } @@ -171,7 +181,7 @@ rn_top_constraint env = rnLHsTyKi (env { rtke_what = RnTopConstraint }) -checkExtraConstraintWildCard :: RnTyKiEnv -> HsWildCardInfo RdrName+checkExtraConstraintWildCard :: RnTyKiEnv -> HsWildCardInfo GhcPs -> RnM () -- Rename the extra-constraint spot in a type signature -- (blah, _) => type@@ -198,11 +208,21 @@ -- without variables that are already in scope in LocalRdrEnv -- NB: this includes named wildcards, which look like perfectly -- ordinary type variables at this point-extractFilteredRdrTyVars :: LHsType RdrName -> RnM FreeKiTyVars+extractFilteredRdrTyVars :: LHsType GhcPs -> RnM FreeKiTyVarsNoDups extractFilteredRdrTyVars hs_ty = do { rdr_env <- getLocalRdrEnv ; filterInScope rdr_env <$> extractHsTyRdrTyVars hs_ty } +-- | Finds free type and kind variables in a type,+-- with duplicates, but+-- without variables that are already in scope in LocalRdrEnv+-- NB: this includes named wildcards, which look like perfectly+-- ordinary type variables at this point+extractFilteredRdrTyVarsDups :: LHsType GhcPs -> RnM FreeKiTyVarsWithDups+extractFilteredRdrTyVarsDups hs_ty+ = do { rdr_env <- getLocalRdrEnv+ ; filterInScope rdr_env <$> extractHsTyRdrTyVarsDups hs_ty }+ -- | When the NamedWildCards extension is enabled, partition_nwcs -- removes type variables that start with an underscore from the -- FreeKiTyVars in the argument and returns them in a separate list.@@ -238,13 +258,14 @@ * * ****************************************************** -} -rnHsSigType :: HsDocContext -> LHsSigType RdrName- -> RnM (LHsSigType Name, FreeVars)+rnHsSigType :: HsDocContext -> LHsSigType GhcPs+ -> RnM (LHsSigType GhcRn, FreeVars) -- Used for source-language type signatures -- that cannot have wildcards rnHsSigType ctx (HsIB { hsib_body = hs_ty })- = do { vars <- extractFilteredRdrTyVars hs_ty- ; rnImplicitBndrs True vars hs_ty $ \ vars ->+ = do { traceRn "rnHsSigType" (ppr hs_ty)+ ; vars <- extractFilteredRdrTyVarsDups hs_ty+ ; rnImplicitBndrs True ctx hs_ty vars $ \ vars -> do { (body', fvs) <- rnLHsType ctx hs_ty ; return ( mk_implicit_bndrs vars body' fvs, fvs ) } } @@ -252,27 +273,50 @@ -- if type is headed by a forall -- E.g. f :: forall a. a->b -- Do not quantify over 'b' too.- -> FreeKiTyVars- -> LHsType RdrName+ -> HsDocContext+ -> LHsType GhcPs -- hs_ty: the type over which the+ -- implicit binders will scope+ -> FreeKiTyVarsWithDups+ -- Free vars of hs_ty (excluding wildcards)+ -- May have duplicates, which is+ -- checked here -> ([Name] -> RnM (a, FreeVars)) -> RnM (a, FreeVars)-rnImplicitBndrs no_implicit_if_forall free_vars hs_ty@(L loc _) thing_inside- = do { let real_tv_rdrs -- Implicit quantification only if- -- there is no explicit forall- | no_implicit_if_forall- , L _ (HsForAllTy {}) <- hs_ty = []- | otherwise = freeKiTyVarsTypeVars free_vars- real_rdrs = freeKiTyVarsKindVars free_vars ++ real_tv_rdrs- ; traceRn "rnSigType" (ppr hs_ty $$ ppr free_vars $$- ppr real_rdrs)+rnImplicitBndrs no_implicit_if_forall doc (L loc hs_ty)+ fvs_with_dups@(FKTV { fktv_kis = kvs_with_dups+ , fktv_tys = tvs_with_dups })+ thing_inside+ = do { let FKTV kvs tvs = rmDupsInRdrTyVars fvs_with_dups+ real_tvs | no_implicit_if_forall+ , HsForAllTy {} <- hs_ty = []+ | otherwise = tvs+ -- Quantify over type variables only if there is no+ -- explicit forall. E.g.+ -- f :: Proxy (a :: k) -> b+ -- Quantify over {k} and {a,b}+ -- g :: forall a. Proxy (a :: k) -> b+ -- Quantify over {k} and {}+ -- Note that we always do the implicit kind-quantification+ -- but, rather arbitrarily, we switch off the type-quantification+ -- if there is an explicit forall - ; traceRn "" (text "rnSigType2" <+> ppr hs_ty $$ ppr free_vars $$- ppr real_rdrs)- ; vars <- mapM (newLocalBndrRn . L loc . unLoc) real_rdrs+ ; traceRn "rnImplicitBndrs" (vcat [ ppr hs_ty, ppr kvs, ppr tvs, ppr real_tvs ])++ ; vars <- mapM (newLocalBndrRn . L loc . unLoc) (kvs ++ real_tvs)++ ; checkBadKindBndrs doc kvs++ ; traceRn "checkMixedVars2" $+ vcat [ text "kvs_with_dups" <+> ppr kvs_with_dups+ , text "tvs_with_dups" <+> ppr tvs_with_dups ]+ ; checkMixedVars kvs_with_dups tvs_with_dups+ -- E.g. Either (Proxy (a :: k)) k+ -- Here 'k' is used at kind level and type level+ ; bindLocalNamesFV vars $ thing_inside vars } -rnLHsInstType :: SDoc -> LHsSigType RdrName -> RnM (LHsSigType Name, FreeVars)+rnLHsInstType :: SDoc -> LHsSigType GhcPs -> RnM (LHsSigType GhcRn, FreeVars) -- Rename the type in an instance or standalone deriving decl -- The 'doc_str' is "an instance declaration" or "a VECTORISE pragma" rnLHsInstType doc_str inst_ty@@ -290,10 +334,10 @@ text "Malformed instance:" <+> ppr inst_ty ; rnHsSigType (GenericCtx doc_str) inst_ty } -mk_implicit_bndrs :: [Name] -- implicitly bound+mk_implicit_bndrs :: [Name] -- implicitly bound -> a -- payload -> FreeVars -- FreeVars of payload- -> HsImplicitBndrs Name a+ -> HsImplicitBndrs GhcRn a mk_implicit_bndrs vars body fvs = HsIB { hsib_vars = vars , hsib_body = body@@ -421,45 +465,47 @@ isRnKindLevel _ = False ---------------rnLHsType :: HsDocContext -> LHsType RdrName -> RnM (LHsType Name, FreeVars)+rnLHsType :: HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars) rnLHsType ctxt ty = rnLHsTyKi (mkTyKiEnv ctxt TypeLevel RnTypeBody) ty -rnLHsTypes :: HsDocContext -> [LHsType RdrName] -> RnM ([LHsType Name], FreeVars)+rnLHsTypes :: HsDocContext -> [LHsType GhcPs] -> RnM ([LHsType GhcRn], FreeVars) rnLHsTypes doc tys = mapFvRn (rnLHsType doc) tys -rnHsType :: HsDocContext -> HsType RdrName -> RnM (HsType Name, FreeVars)+rnHsType :: HsDocContext -> HsType GhcPs -> RnM (HsType GhcRn, FreeVars) rnHsType ctxt ty = rnHsTyKi (mkTyKiEnv ctxt TypeLevel RnTypeBody) ty -rnLHsKind :: HsDocContext -> LHsKind RdrName -> RnM (LHsKind Name, FreeVars)+rnLHsKind :: HsDocContext -> LHsKind GhcPs -> RnM (LHsKind GhcRn, FreeVars) rnLHsKind ctxt kind = rnLHsTyKi (mkTyKiEnv ctxt KindLevel RnTypeBody) kind -rnHsKind :: HsDocContext -> HsKind RdrName -> RnM (HsKind Name, FreeVars)+rnHsKind :: HsDocContext -> HsKind GhcPs -> RnM (HsKind GhcRn, FreeVars) rnHsKind ctxt kind = rnHsTyKi (mkTyKiEnv ctxt KindLevel RnTypeBody) kind ---------------rnTyKiContext :: RnTyKiEnv -> LHsContext RdrName -> RnM (LHsContext Name, FreeVars)+rnTyKiContext :: RnTyKiEnv -> LHsContext GhcPs+ -> RnM (LHsContext GhcRn, FreeVars) rnTyKiContext env (L loc cxt) = do { traceRn "rncontext" (ppr cxt) ; let env' = env { rtke_what = RnConstraint } ; (cxt', fvs) <- mapFvRn (rnLHsTyKi env') cxt ; return (L loc cxt', fvs) } -rnContext :: HsDocContext -> LHsContext RdrName -> RnM (LHsContext Name, FreeVars)+rnContext :: HsDocContext -> LHsContext GhcPs+ -> RnM (LHsContext GhcRn, FreeVars) rnContext doc theta = rnTyKiContext (mkTyKiEnv doc TypeLevel RnConstraint) theta ---------------rnLHsTyKi :: RnTyKiEnv -> LHsType RdrName -> RnM (LHsType Name, FreeVars)+rnLHsTyKi :: RnTyKiEnv -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars) rnLHsTyKi env (L loc ty) = setSrcSpan loc $ do { (ty', fvs) <- rnHsTyKi env ty ; return (L loc ty', fvs) } -rnHsTyKi :: RnTyKiEnv -> HsType RdrName -> RnM (HsType Name, FreeVars)+rnHsTyKi :: RnTyKiEnv -> HsType GhcPs -> RnM (HsType GhcRn, FreeVars) rnHsTyKi env ty@(HsForAllTy { hst_bndrs = tyvars, hst_body = tau }) = do { checkTypeInType env ty ; bindLHsTyVarBndrs (rtke_ctxt env) (Just $ inTypeDoc ty)- Nothing [] tyvars $ \ _ tyvars' _ _ ->+ Nothing tyvars $ \ tyvars' -> do { (tau', fvs) <- rnLHsTyKi env tau ; return ( HsForAllTy { hst_bndrs = tyvars', hst_body = tau' } , fvs) } }@@ -586,9 +632,9 @@ ; return (res_ty, fvs1 `plusFV` fvs2) } where -- See Note [Dealing with *]- deal_with_star :: [[LHsType Name]] -> [Located Name]- -> [[LHsType Name]] -> [Located Name]- -> ([[LHsType Name]], [Located Name])+ deal_with_star :: [[LHsType GhcRn]] -> [Located Name]+ -> [[LHsType GhcRn]] -> [Located Name]+ -> ([[LHsType GhcRn]], [Located Name]) deal_with_star acc1 acc2 (non_syms1 : non_syms2 : non_syms) (L loc star : ops) | star `hasKey` starKindTyConKey || star `hasKey` unicodeStarKindTyConKey@@ -603,14 +649,14 @@ deal_with_star _ _ _ _ = pprPanic "deal_with_star" (ppr overall_ty) - -- collapse [LHsType Name] to LHsType Name by making applications+ -- collapse [LHsType GhcRn] to LHsType GhcRn by making applications -- monadic only for failure- deal_with_non_syms :: [LHsType Name] -> RnM (LHsType Name)+ deal_with_non_syms :: [LHsType GhcRn] -> RnM (LHsType GhcRn) deal_with_non_syms (non_sym : non_syms) = return $ mkHsAppTys non_sym non_syms deal_with_non_syms [] = failWith (emptyNonSymsErr overall_ty) -- assemble a right-biased OpTy for use in mkHsOpTyRn- build_res_ty :: [LHsType Name] -> [Located Name] -> RnM (LHsType Name)+ build_res_ty :: [LHsType GhcRn] -> [Located Name] -> RnM (LHsType GhcRn) build_res_ty (arg1 : args) (op1 : ops) = do { rhs <- build_res_ty args ops ; fix <- lookupTyFixityRn op1@@ -690,7 +736,8 @@ -------------- rnHsTyOp :: Outputable a- => RnTyKiEnv -> a -> Located RdrName -> RnM (Located Name, FreeVars)+ => RnTyKiEnv -> a -> Located RdrName+ -> RnM (Located Name, FreeVars) rnHsTyOp env overall_ty (L loc op) = do { ops_ok <- xoptM LangExt.TypeOperators ; op' <- rnTyVar env op@@ -713,8 +760,8 @@ checkWildCard _ Nothing = return () -checkAnonWildCard :: RnTyKiEnv -> HsWildCardInfo RdrName -> RnM ()--- Report an error if an anonymoous wildcard is illegal here+checkAnonWildCard :: RnTyKiEnv -> HsWildCardInfo GhcPs -> RnM ()+-- Report an error if an anonymous wildcard is illegal here checkAnonWildCard env wc = checkWildCard env mb_bad where@@ -763,7 +810,7 @@ HsTypeCtx {} -> True _ -> False -rnAnonWildCard :: HsWildCardInfo RdrName -> RnM (HsWildCardInfo Name)+rnAnonWildCard :: HsWildCardInfo GhcPs -> RnM (HsWildCardInfo GhcRn) rnAnonWildCard (AnonWildCard _) = do { loc <- getSrcSpanM ; uniq <- newUnique@@ -826,201 +873,204 @@ --------------- bindHsQTyVars :: forall a b. HsDocContext- -> Maybe SDoc -- if we are to check for unused tvs,- -- a phrase like "in the type ..."- -> Maybe a -- Just _ => an associated type decl- -> [Located RdrName] -- Kind variables from scope, in l-to-r- -- order, but not from ...- -> (LHsQTyVars RdrName) -- ... these user-written tyvars- -> (LHsQTyVars Name -> NameSet -> RnM (b, FreeVars))- -- also returns all names used in kind signatures, for the- -- TypeInType clause of Note [Complete user-supplied kind- -- signatures] in HsDecls+ -> Maybe SDoc -- Just d => check for unused tvs+ -- d is a phrase like "in the type ..."+ -> Maybe a -- Just _ => an associated type decl+ -> [Located RdrName] -- Kind variables from scope, no dups+ -> (LHsQTyVars GhcPs)+ -> (LHsQTyVars GhcRn -> Bool -> RnM (b, FreeVars))+ -- The Bool is True <=> all kind variables used in the+ -- kind signature are bound on the left. Reason:+ -- the TypeInType clause of Note [Complete user-supplied+ -- kind signatures] in HsDecls -> RnM (b, FreeVars)++-- See Note [bindHsQTyVars examples] -- (a) Bring kind variables into scope--- both (i) passed in (kv_bndrs)--- and (ii) mentioned in the kinds of tv_bndrs+-- both (i) passed in body_kv_occs+-- and (ii) mentioned in the kinds of hsq_bndrs -- (b) Bring type variables into scope-bindHsQTyVars doc mb_in_doc mb_assoc kv_bndrs tv_bndrs thing_inside- = do { bindLHsTyVarBndrs doc mb_in_doc- mb_assoc kv_bndrs (hsQTvExplicit tv_bndrs) $- \ rn_kvs rn_bndrs dep_var_set all_dep_vars ->- thing_inside (HsQTvs { hsq_implicit = rn_kvs- , hsq_explicit = rn_bndrs- , hsq_dependent = dep_var_set }) all_dep_vars }+--+bindHsQTyVars doc mb_in_doc mb_assoc body_kv_occs hsq_bndrs thing_inside+ = do { let hs_tv_bndrs = hsQTvExplicit hsq_bndrs+ ; bndr_kv_occs <- extractHsTyVarBndrsKVs hs_tv_bndrs+ ; rdr_env <- getLocalRdrEnv -bindLHsTyVarBndrs :: forall a b.- HsDocContext- -> Maybe SDoc -- if we are to check for unused tvs,- -- a phrase like "in the type ..."- -> Maybe a -- Just _ => an associated type decl- -> [Located RdrName] -- Unbound kind variables from scope,- -- in l-to-r order, but not from ...- -> [LHsTyVarBndr RdrName] -- ... these user-written tyvars- -> ( [Name] -- all kv names- -> [LHsTyVarBndr Name]- -> NameSet -- which names, from the preceding list,- -- are used dependently within that list- -- See Note [Dependent LHsQTyVars] in TcHsType- -> NameSet -- all names used in kind signatures- -> RnM (b, FreeVars))- -> RnM (b, FreeVars)-bindLHsTyVarBndrs doc mb_in_doc mb_assoc kv_bndrs tv_bndrs thing_inside- = do { when (isNothing mb_assoc) (checkShadowedRdrNames tv_names_w_loc)- ; go [] [] emptyNameSet emptyNameSet emptyNameSet tv_bndrs }+ ; let -- See Note [bindHsQTyVars examples] for what+ -- all these various things are doing+ bndrs, kv_occs, implicit_bndr_kvs,+ implicit_body_kvs, implicit_kvs :: [Located RdrName]+ bndrs = map hsLTyVarLocName hs_tv_bndrs+ kv_occs = body_kv_occs ++ bndr_kv_occs+ implicit_bndr_kvs = filter_occs rdr_env bndrs bndr_kv_occs+ implicit_body_kvs = filter_occs rdr_env (implicit_bndr_kvs ++ bndrs) body_kv_occs+ -- Deleting bndrs: See Note [Kind-variable ordering]+ implicit_kvs = implicit_bndr_kvs ++ implicit_body_kvs++ -- dep_bndrs is the subset of bndrs that are dependent+ -- i.e. appear in bndr/body_kv_occs+ -- Can't use implicit_kvs because we've deleted bndrs from that!+ dep_bndrs = filter (`elemRdr` kv_occs) bndrs++ ; traceRn "checkMixedVars3" $+ vcat [ text "kv_occs" <+> ppr kv_occs+ , text "bndrs" <+> ppr bndrs ]+ ; checkBadKindBndrs doc implicit_kvs+ ; checkMixedVars kv_occs bndrs++ ; implicit_kv_nms <- mapM (newTyVarNameRn mb_assoc) implicit_kvs++ ; bindLocalNamesFV implicit_kv_nms $+ bindLHsTyVarBndrs doc mb_in_doc mb_assoc hs_tv_bndrs $ \ rn_bndrs ->+ do { traceRn "bindHsQTyVars" (ppr hsq_bndrs $$ ppr implicit_kv_nms $$ ppr rn_bndrs)+ ; dep_bndr_nms <- mapM (lookupLocalOccRn . unLoc) dep_bndrs+ ; thing_inside (HsQTvs { hsq_implicit = implicit_kv_nms+ , hsq_explicit = rn_bndrs+ , hsq_dependent = mkNameSet dep_bndr_nms })+ (null implicit_body_kvs) } }+ where- tv_names_w_loc = map hsLTyVarLocName tv_bndrs+ filter_occs :: LocalRdrEnv -- In scope+ -> [Located RdrName] -- Bound here+ -> [Located RdrName] -- Potential implicit binders+ -> [Located RdrName] -- Final implicit binders+ -- Filter out any potential implicit binders that are either+ -- already in scope, or are explicitly bound here+ filter_occs rdr_env bndrs occs+ = filterOut is_in_scope occs+ where+ is_in_scope locc@(L _ occ) = isJust (lookupLocalRdrEnv rdr_env occ)+ || locc `elemRdr` bndrs - go :: [Name] -- kind-vars found (in reverse order)- -> [LHsTyVarBndr Name] -- already renamed (in reverse order)- -> NameSet -- kind vars already in scope (for dup checking)- -> NameSet -- type vars already in scope (for dup checking)- -> NameSet -- (all) variables used dependently- -> [LHsTyVarBndr RdrName] -- still to be renamed, scoped- -> RnM (b, FreeVars)- go rn_kvs rn_tvs kv_names tv_names dep_vars (tv_bndr : tv_bndrs)- = bindLHsTyVarBndr doc mb_assoc kv_names tv_names tv_bndr $- \ kv_nms used_dependently tv_bndr' ->- do { (b, fvs) <- go (reverse kv_nms ++ rn_kvs)- (tv_bndr' : rn_tvs)- (kv_names `extendNameSetList` kv_nms)- (tv_names `extendNameSet` hsLTyVarName tv_bndr')- (dep_vars `unionNameSet` used_dependently)- tv_bndrs- ; warn_unused tv_bndr' fvs- ; return (b, fvs) }+{- Note [bindHsQTyVars examples]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we have+ data T k (a::k1) (b::k) :: k2 -> k1 -> * - go rn_kvs rn_tvs _kv_names tv_names dep_vars []- = -- still need to deal with the kv_bndrs passed in originally- bindImplicitKvs doc mb_assoc kv_bndrs tv_names $ \ kv_nms others ->- do { let all_rn_kvs = reverse (reverse kv_nms ++ rn_kvs)- all_rn_tvs = reverse rn_tvs- ; env <- getLocalRdrEnv- ; let all_dep_vars = dep_vars `unionNameSet` others- exp_dep_vars -- variables in all_rn_tvs that are in dep_vars- = mkNameSet [ name- | v <- all_rn_tvs- , let name = hsLTyVarName v- , name `elemNameSet` all_dep_vars ]- ; traceRn "bindHsTyVars" (ppr env $$- ppr all_rn_kvs $$- ppr all_rn_tvs $$- ppr exp_dep_vars)- ; thing_inside all_rn_kvs all_rn_tvs exp_dep_vars all_dep_vars }+Then:+ hs_tv_bndrs = [k, a::k1, b::k], the explicitly-bound variables+ bndrs = [k,a,b] - warn_unused tv_bndr fvs = case mb_in_doc of- Just in_doc -> warnUnusedForAll in_doc tv_bndr fvs- Nothing -> return ()+ bndr_kv_occs = [k,k1], kind variables free in kind signatures+ of hs_tv_bndrs -bindLHsTyVarBndr :: HsDocContext- -> Maybe a -- associated class- -> NameSet -- kind vars already in scope- -> NameSet -- type vars already in scope- -> LHsTyVarBndr RdrName- -> ([Name] -> NameSet -> LHsTyVarBndr Name -> RnM (b, FreeVars))- -- passed the newly-bound implicitly-declared kind vars,- -- any other names used in a kind- -- and the renamed LHsTyVarBndr- -> RnM (b, FreeVars)-bindLHsTyVarBndr doc mb_assoc kv_names tv_names hs_tv_bndr thing_inside- = case hs_tv_bndr of- L loc (UserTyVar lrdr@(L lv rdr)) ->- do { check_dup loc rdr []- ; nm <- newTyVarNameRn mb_assoc lrdr- ; bindLocalNamesFV [nm] $- thing_inside [] emptyNameSet (L loc (UserTyVar (L lv nm))) }- L loc (KindedTyVar lrdr@(L lv rdr) kind) ->- do { free_kvs <- freeKiTyVarsAllVars <$> extractHsTyRdrTyVars kind- ; check_dup lv rdr (map unLoc free_kvs)+ body_kv_occs = [k2,k1], kind variables free in the+ result kind signature - -- check for -XKindSignatures- ; sig_ok <- xoptM LangExt.KindSignatures- ; unless sig_ok (badKindSigErr doc kind)+ implicit_bndr_kvs = [k1], kind variables free in kind signatures+ of hs_tv_bndrs, and not bound by bndrs - -- deal with kind vars in the user-written kind- ; bindImplicitKvs doc mb_assoc free_kvs tv_names $- \ new_kv_nms other_kv_nms ->- do { (kind', fvs1) <- rnLHsKind doc kind- ; tv_nm <- newTyVarNameRn mb_assoc lrdr- ; (b, fvs2) <- bindLocalNamesFV [tv_nm] $- thing_inside new_kv_nms other_kv_nms- (L loc (KindedTyVar (L lv tv_nm) kind'))- ; return (b, fvs1 `plusFV` fvs2) }}- where- -- make sure that the RdrName isn't in the sets of- -- names. We can't just check that it's not in scope at all- -- because we might be inside an associated class.- check_dup :: SrcSpan -> RdrName -> [RdrName] -> RnM ()- check_dup loc rdr kindFreeVars- = do { -- Disallow use of a type variable name in its- -- kind signature (#11592).- when (rdr `elem` kindFreeVars) $- addErrAt loc (vcat [ ki_ty_self_err rdr- , pprHsDocContext doc ])+ implicit_body_kvs = [k2], kind variables free in the result kind+ signature, and not bound either by+ bndrs or by implicit_bndr_kvs - ; m_name <- lookupLocalOccRn_maybe rdr- ; whenIsJust m_name $ \name ->- do { when (name `elemNameSet` kv_names) $- addErrAt loc (vcat [ ki_ty_err_msg name- , pprHsDocContext doc ])- ; when (name `elemNameSet` tv_names) $- dupNamesErr getLoc [L loc name, L (nameSrcSpan name) name] }}+* We want to quantify add implicit bindings for+ implicit_bndr_kvs and implicit_body_kvs - ki_ty_err_msg n = text "Variable" <+> quotes (ppr n) <+>- text "used as a kind variable before being bound" $$- text "as a type variable. Perhaps reorder your variables?"+* The "dependent" bndrs (hsq_dependent) are the subset of+ bndrs that are free in bndr_kv_occs or body_kv_occs - ki_ty_self_err n = text "Variable" <+> quotes (ppr n) <+>- text "is used in the kind signature of its" $$- text "declaration as a type variable."+* If implicit_body_kvs is non-empty, then there is a kind variable+ mentioned in the kind signature that is not bound "on the left".+ That's one of the rules for a CUSK, so we pass that info on+ as the second argument to thing_inside. +* Order is not important in these lists. All we are doing is+ bring Names into scope. -bindImplicitKvs :: HsDocContext- -> Maybe a- -> [Located RdrName] -- ^ kind var *occurrences*, from which- -- intent to bind is inferred- -> NameSet -- ^ *type* variables, for type/kind- -- misuse check for -XNoTypeInType- -> ([Name] -> NameSet -> RnM (b, FreeVars))- -- ^ passed new kv_names, and any other names used in a kind- -> RnM (b, FreeVars)-bindImplicitKvs _ _ [] _ thing_inside- = thing_inside [] emptyNameSet-bindImplicitKvs doc mb_assoc free_kvs tv_names thing_inside- = do { rdr_env <- getLocalRdrEnv- ; let part_kvs lrdr@(L loc kv_rdr)- = case lookupLocalRdrEnv rdr_env kv_rdr of- Just kv_name -> Left (L loc kv_name)- _ -> Right lrdr- (bound_kvs, new_kvs) = partitionWith part_kvs free_kvs+Finally, you may wonder why filter_occs removes in-scope variables+from bndr/body_kv_occs. How can anything be in scope? Answer:+HsQTyVars is /also/ used (slightly oddly) for Haskell-98 syntax+ConDecls+ data T a = forall (b::k). MkT a b+The ConDecl has a LHsQTyVars in it; but 'a' scopes over the entire+ConDecl. Hence the local RdrEnv may be non-empty and we must filter+out 'a' from the free vars. (Mind you, in this situation all the+implicit kind variables are bound at the data type level, so there+are none to bind in the ConDecl, so there are no implicitly bound+variables at all. - -- check whether we're mixing types & kinds illegally- ; type_in_type <- xoptM LangExt.TypeInType- ; unless type_in_type $- mapM_ (check_tv_used_in_kind tv_names) bound_kvs+Note [Kind variable scoping]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we have+ data T (a :: k) k = ...+we report "k is out of scope" for (a::k). Reason: k is not brought+into scope until the explicit k-binding that follows. It would be+terribly confusing to bring into scope an /implicit/ k for a's kind+and a distinct, shadowing explicit k that follows, something like+ data T {k1} (a :: k1) k = ... - ; poly_kinds <- xoptM LangExt.PolyKinds- ; unless poly_kinds $- addErr (badKindBndrs doc new_kvs)+So the rule is: - -- bind the vars and move on- ; kv_nms <- mapM (newTyVarNameRn mb_assoc) new_kvs- ; bindLocalNamesFV kv_nms $- thing_inside kv_nms (mkNameSet (map unLoc bound_kvs)) }+ the implicit binders never include any+ of the explicit binders in the group++Note that in the denerate case+ data T (a :: a) = blah+we get a complaint the the second 'a' is not in scope.++That applies to foralls too: e.g.+ forall (a :: k) k . blah++But if the foralls are split, we treat the two groups separately:+ forall (a :: k). forall k. blah+Here we bring into scope an implicit k, which is later shadowed+by the explicit k.++In implementation terms++* In bindHsQTyVars 'k' is free in bndr_kv_occs; then we delete+ the binders {a,k}, and so end with no implicit binders. Then we+ rename the binders left-to-right, and hence see that 'k' is out of+ scope in the kind of 'a'.++* Similarly in extract_hs_tv_bndrs+-}++bindLHsTyVarBndrs :: HsDocContext+ -> Maybe SDoc -- Just d => check for unused tvs+ -- d is a phrase like "in the type ..."+ -> Maybe a -- Just _ => an associated type decl+ -> [LHsTyVarBndr GhcPs] -- User-written tyvars+ -> ([LHsTyVarBndr GhcRn] -> RnM (b, FreeVars))+ -> RnM (b, FreeVars)+bindLHsTyVarBndrs doc mb_in_doc mb_assoc tv_bndrs thing_inside+ = do { when (isNothing mb_assoc) (checkShadowedRdrNames tv_names_w_loc)+ ; checkDupRdrNames tv_names_w_loc+ ; go tv_bndrs thing_inside } where- -- check to see if the variables free in a kind are bound as type- -- variables. Assume -XNoTypeInType.- check_tv_used_in_kind :: NameSet -- ^ *type* variables- -> Located Name -- ^ renamed var used in kind- -> RnM ()- check_tv_used_in_kind tv_names (L loc kv_name)- = when (kv_name `elemNameSet` tv_names) $- addErrAt loc (vcat [ text "Type variable" <+> quotes (ppr kv_name) <+>- text "used in a kind." $$- text "Did you mean to use TypeInType?"- , pprHsDocContext doc ])+ tv_names_w_loc = map hsLTyVarLocName tv_bndrs + go [] thing_inside = thing_inside []+ go (b:bs) thing_inside = bindLHsTyVarBndr doc mb_assoc b $ \ b' ->+ do { (res, fvs) <- go bs $ \ bs' ->+ thing_inside (b' : bs')+ ; warn_unused b' fvs+ ; return (res, fvs) } + warn_unused tv_bndr fvs = case mb_in_doc of+ Just in_doc -> warnUnusedForAll in_doc tv_bndr fvs+ Nothing -> return ()++bindLHsTyVarBndr :: HsDocContext+ -> Maybe a -- associated class+ -> LHsTyVarBndr GhcPs+ -> (LHsTyVarBndr GhcRn -> RnM (b, FreeVars))+ -> RnM (b, FreeVars)+bindLHsTyVarBndr _doc mb_assoc (L loc (UserTyVar lrdr@(L lv _))) thing_inside+ = do { nm <- newTyVarNameRn mb_assoc lrdr+ ; bindLocalNamesFV [nm] $+ thing_inside (L loc (UserTyVar (L lv nm))) }++bindLHsTyVarBndr doc mb_assoc (L loc (KindedTyVar lrdr@(L lv _) kind)) thing_inside+ = do { sig_ok <- xoptM LangExt.KindSignatures+ ; unless sig_ok (badKindSigErr doc kind)+ ; (kind', fvs1) <- rnLHsKind doc kind+ ; tv_nm <- newTyVarNameRn mb_assoc lrdr+ ; (b, fvs2) <- bindLocalNamesFV [tv_nm] $+ thing_inside (L loc (KindedTyVar (L lv tv_nm) kind'))+ ; return (b, fvs1 `plusFV` fvs2) }+ newTyVarNameRn :: Maybe a -> Located RdrName -> RnM Name newTyVarNameRn mb_assoc (L loc rdr) = do { rdr_env <- getLocalRdrEnv@@ -1031,7 +1081,7 @@ _ -> newLocalBndrRn (L loc rdr) } ----------------------collectAnonWildCards :: LHsType Name -> [Name]+collectAnonWildCards :: LHsType GhcRn -> [Name] -- | Extract all wild cards from a type. collectAnonWildCards lty = go lty where@@ -1070,7 +1120,7 @@ prefix_types_only (HsAppPrefix ty) = Just ty prefix_types_only (HsAppInfix _) = Nothing -collectAnonWildCardsBndrs :: [LHsTyVarBndr Name] -> [Name]+collectAnonWildCardsBndrs :: [LHsTyVarBndr GhcRn] -> [Name] collectAnonWildCardsBndrs ltvs = concatMap (go . unLoc) ltvs where go (UserTyVar _) = []@@ -1090,8 +1140,8 @@ argument, build a map and look them up. -} -rnConDeclFields :: HsDocContext -> [FieldLabel] -> [LConDeclField RdrName]- -> RnM ([LConDeclField Name], FreeVars)+rnConDeclFields :: HsDocContext -> [FieldLabel] -> [LConDeclField GhcPs]+ -> RnM ([LConDeclField GhcRn], FreeVars) -- Also called from RnSource -- No wildcards can appear in record fields rnConDeclFields ctxt fls fields@@ -1100,15 +1150,15 @@ env = mkTyKiEnv ctxt TypeLevel RnTypeBody fl_env = mkFsEnv [ (flLabel fl, fl) | fl <- fls ] -rnField :: FastStringEnv FieldLabel -> RnTyKiEnv -> LConDeclField RdrName- -> RnM (LConDeclField Name, FreeVars)+rnField :: FastStringEnv FieldLabel -> RnTyKiEnv -> LConDeclField GhcPs+ -> RnM (LConDeclField GhcRn, FreeVars) rnField fl_env env (L l (ConDeclField names ty haddock_doc)) = do { let new_names = map (fmap lookupField) names ; (new_ty, fvs) <- rnLHsTyKi env ty ; new_haddock_doc <- rnMbLHsDoc haddock_doc ; return (L l (ConDeclField new_names new_ty new_haddock_doc), fvs) } where- lookupField :: FieldOcc RdrName -> FieldOcc Name+ lookupField :: FieldOcc GhcPs -> FieldOcc GhcRn lookupField (FieldOcc (L lr rdr) _) = FieldOcc (L lr rdr) (flSelector fl) where lbl = occNameFS $ rdrNameOcc rdr@@ -1142,9 +1192,9 @@ --------------- -- Building (ty1 `op1` (ty21 `op2` ty22))-mkHsOpTyRn :: (LHsType Name -> LHsType Name -> HsType Name)- -> Name -> Fixity -> LHsType Name -> LHsType Name- -> RnM (HsType Name)+mkHsOpTyRn :: (LHsType GhcRn -> LHsType GhcRn -> HsType GhcRn)+ -> Name -> Fixity -> LHsType GhcRn -> LHsType GhcRn+ -> RnM (HsType GhcRn) mkHsOpTyRn mk1 pp_op1 fix1 ty1 (L loc2 (HsOpTy ty21 op2 ty22)) = do { fix2 <- lookupTyFixityRn op2@@ -1160,11 +1210,11 @@ = return (mk1 ty1 ty2) ----------------mk_hs_op_ty :: (LHsType Name -> LHsType Name -> HsType Name)- -> Name -> Fixity -> LHsType Name- -> (LHsType Name -> LHsType Name -> HsType Name)- -> Name -> Fixity -> LHsType Name -> LHsType Name -> SrcSpan- -> RnM (HsType Name)+mk_hs_op_ty :: (LHsType GhcRn -> LHsType GhcRn -> HsType GhcRn)+ -> Name -> Fixity -> LHsType GhcRn+ -> (LHsType GhcRn -> LHsType GhcRn -> HsType GhcRn)+ -> Name -> Fixity -> LHsType GhcRn -> LHsType GhcRn -> SrcSpan+ -> RnM (HsType GhcRn) mk_hs_op_ty mk1 op1 fix1 ty1 mk2 op2 fix2 ty21 ty22 loc2 | nofix_error = do { precParseErr (NormalOp op1,fix1) (NormalOp op2,fix2)@@ -1178,11 +1228,11 @@ ----------------------------mkOpAppRn :: LHsExpr Name -- Left operand; already rearranged- -> LHsExpr Name -> Fixity -- Operator and fixity- -> LHsExpr Name -- Right operand (not an OpApp, but might- -- be a NegApp)- -> RnM (HsExpr Name)+mkOpAppRn :: LHsExpr GhcRn -- Left operand; already rearranged+ -> LHsExpr GhcRn -> Fixity -- Operator and fixity+ -> LHsExpr GhcRn -- Right operand (not an OpApp, but might+ -- be a NegApp)+ -> RnM (HsExpr GhcRn) -- (e11 `op1` e12) `op2` e2 mkOpAppRn e1@(L _ (OpApp e11 op1 fix1 e12)) op2 fix2 e2@@ -1234,7 +1284,7 @@ data OpName = NormalOp Name -- ^ A normal identifier | NegateOp -- ^ Prefix negation | UnboundOp UnboundVar -- ^ An unbound indentifier- | RecFldOp (AmbiguousFieldOcc Name)+ | RecFldOp (AmbiguousFieldOcc GhcRn) -- ^ A (possibly ambiguous) record field occurrence instance Outputable OpName where@@ -1243,7 +1293,7 @@ ppr (UnboundOp uv) = ppr uv ppr (RecFldOp fld) = ppr fld -get_op :: LHsExpr Name -> OpName+get_op :: LHsExpr GhcRn -> OpName -- An unbound name could be either HsVar or HsUnboundVar -- See RnExpr.rnUnboundVar get_op (L _ (HsVar (L _ n))) = NormalOp n@@ -1254,7 +1304,7 @@ -- Parser left-associates everything, but -- derived instances may have correctly-associated things to -- in the right operand. So we just check that the right operand is OK-right_op_ok :: Fixity -> HsExpr Name -> Bool+right_op_ok :: Fixity -> HsExpr GhcRn -> Bool right_op_ok fix1 (OpApp _ _ fix2 _) = not error_please && associate_right where@@ -1274,10 +1324,10 @@ not_op_app _ = True ----------------------------mkOpFormRn :: LHsCmdTop Name -- Left operand; already rearranged- -> LHsExpr Name -> Fixity -- Operator and fixity- -> LHsCmdTop Name -- Right operand (not an infix)- -> RnM (HsCmd Name)+mkOpFormRn :: LHsCmdTop GhcRn -- Left operand; already rearranged+ -> LHsExpr GhcRn -> Fixity -- Operator and fixity+ -> LHsCmdTop GhcRn -- Right operand (not an infix)+ -> RnM (HsCmd GhcRn) -- (e11 `op1` e12) `op2` e2 mkOpFormRn a1@(L loc (HsCmdTop (L _ (HsCmdArrForm op1 f (Just fix1)@@ -1302,8 +1352,8 @@ ---------------------------------------mkConOpPatRn :: Located Name -> Fixity -> LPat Name -> LPat Name- -> RnM (Pat Name)+mkConOpPatRn :: Located Name -> Fixity -> LPat GhcRn -> LPat GhcRn+ -> RnM (Pat GhcRn) mkConOpPatRn op2 fix2 p1@(L loc (ConPatIn op1 (InfixCon p11 p12))) p2 = do { fix1 <- lookupFixityRn (unLoc op1)@@ -1323,12 +1373,12 @@ = ASSERT( not_op_pat (unLoc p2) ) return (ConPatIn op (InfixCon p1 p2)) -not_op_pat :: Pat Name -> Bool+not_op_pat :: Pat GhcRn -> Bool not_op_pat (ConPatIn _ (InfixCon _ _)) = False not_op_pat _ = True ---------------------------------------checkPrecMatch :: Name -> MatchGroup Name body -> RnM ()+checkPrecMatch :: Name -> MatchGroup GhcRn body -> RnM () -- Check precedence of a function binding written infix -- eg a `op` b `C` c = ... -- See comments with rnExpr (OpApp ...) about "deriving"@@ -1336,7 +1386,7 @@ checkPrecMatch op (MG { mg_alts = L _ ms }) = mapM_ check ms where- check (L _ (Match _ (L l1 p1 : L l2 p2 :_) _ _))+ check (L _ (Match { m_pats = L l1 p1 : L l2 p2 :_ })) = setSrcSpan (combineSrcSpans l1 l2) $ do checkPrec op p1 False checkPrec op p2 True@@ -1350,7 +1400,7 @@ -- until the type checker). So we don't want to crash on the -- second eqn. -checkPrec :: Name -> Pat Name -> Bool -> IOEnv (Env TcGblEnv TcLclEnv) ()+checkPrec :: Name -> Pat GhcRn -> Bool -> IOEnv (Env TcGblEnv TcLclEnv) () checkPrec op (ConPatIn op1 (InfixCon _ _)) right = do op_fix@(Fixity _ op_prec op_dir) <- lookupFixityRn op op1_fix@(Fixity _ op1_prec op1_dir) <- lookupFixityRn (unLoc op1)@@ -1372,8 +1422,8 @@ -- If arg is itself an operator application, then either -- (a) its precedence must be higher than that of op -- (b) its precedency & associativity must be the same as that of op-checkSectionPrec :: FixityDirection -> HsExpr RdrName- -> LHsExpr Name -> LHsExpr Name -> RnM ()+checkSectionPrec :: FixityDirection -> HsExpr GhcPs+ -> LHsExpr GhcRn -> LHsExpr GhcRn -> RnM () checkSectionPrec direction section op arg = case unLoc arg of OpApp _ op' fix _ -> go_for_it (get_op op') fix@@ -1410,7 +1460,7 @@ ppr_opfix op2, text "in the same infix expression"]) -sectionPrecErr :: (OpName,Fixity) -> (OpName,Fixity) -> HsExpr RdrName -> RnM ()+sectionPrecErr :: (OpName,Fixity) -> (OpName,Fixity) -> HsExpr GhcPs -> RnM () sectionPrecErr op@(n1,_) arg_op@(n2,_) section | is_unbound n1 || is_unbound n2 = return () -- Avoid error cascade@@ -1438,26 +1488,28 @@ * * ***************************************************** -} -unexpectedTypeSigErr :: LHsSigWcType RdrName -> SDoc+unexpectedTypeSigErr :: LHsSigWcType GhcPs -> SDoc unexpectedTypeSigErr ty = hang (text "Illegal type signature:" <+> quotes (ppr ty)) 2 (text "Type signatures are only allowed in patterns with ScopedTypeVariables") -badKindBndrs :: HsDocContext -> [Located RdrName] -> SDoc-badKindBndrs doc kvs- = withHsDocContext doc $- hang (text "Unexpected kind variable" <> plural kvs- <+> pprQuotedList kvs)- 2 (text "Perhaps you intended to use PolyKinds")+checkBadKindBndrs :: HsDocContext -> [Located RdrName] -> RnM ()+checkBadKindBndrs doc kvs+ = unless (null kvs) $+ unlessXOptM LangExt.PolyKinds $+ addErr (withHsDocContext doc $+ hang (text "Unexpected kind variable" <> plural kvs+ <+> pprQuotedList kvs)+ 2 (text "Perhaps you intended to use PolyKinds")) -badKindSigErr :: HsDocContext -> LHsType RdrName -> TcM ()+badKindSigErr :: HsDocContext -> LHsType GhcPs -> TcM () badKindSigErr doc (L loc ty) = setSrcSpan loc $ addErr $ withHsDocContext doc $ hang (text "Illegal kind signature:" <+> quotes (ppr ty)) 2 (text "Perhaps you intended to use KindSignatures") -dataKindsErr :: RnTyKiEnv -> HsType RdrName -> SDoc+dataKindsErr :: RnTyKiEnv -> HsType GhcPs -> SDoc dataKindsErr env thing = hang (text "Illegal" <+> pp_what <> colon <+> quotes (ppr thing)) 2 (text "Perhaps you intended to use DataKinds")@@ -1465,10 +1517,10 @@ pp_what | isRnKindLevel env = text "kind" | otherwise = text "type" -inTypeDoc :: HsType RdrName -> SDoc+inTypeDoc :: HsType GhcPs -> SDoc inTypeDoc ty = text "In the type" <+> quotes (ppr ty) -warnUnusedForAll :: SDoc -> LHsTyVarBndr Name -> FreeVars -> TcM ()+warnUnusedForAll :: SDoc -> LHsTyVarBndr GhcRn -> FreeVars -> TcM () warnUnusedForAll in_doc (L loc tv) used_names = whenWOptM Opt_WarnUnusedForalls $ unless (hsTyVarName tv `elemNameSet` used_names) $@@ -1486,7 +1538,7 @@ | otherwise = text "Use TypeOperators to allow operators in types" -emptyNonSymsErr :: HsType RdrName -> SDoc+emptyNonSymsErr :: HsType GhcPs -> SDoc emptyNonSymsErr overall_ty = text "Operator applied to too few arguments:" <+> ppr overall_ty @@ -1523,17 +1575,52 @@ * Its free type variables * The free kind variables of any kind signatures in the type -Hence we returns a pair (kind-vars, type vars)+Hence we return a pair (kind-vars, type vars) See also Note [HsBSig binder lists] in HsTypes++Most clients of this code just want to know the kind/type vars, without+duplicates. The function rmDupsInRdrTyVars removes duplicates. That function+also makes sure that no variable is reported as both a kind var and+a type var, preferring kind vars. Why kind vars? Consider this:++ foo :: forall (a :: k). Proxy k -> Proxy a -> ...++Should that be accepted?++Normally, if a type signature has an explicit forall, it must list *all*+tyvars mentioned in the type. But there's an exception for tyvars mentioned in+a kind, as k is above. Note that k is also used "as a type variable", as the+argument to the first Proxy. So, do we consider k to be type-variable-like and+require it in the forall? Or do we consider k to be kind-variable-like and not+require it?++It's not just in type signatures: kind variables are implicitly brought into+scope in a variety of places. Should vars used at both the type level and kind+level be treated this way?++GHC indeed allows kind variables to be brought into scope implicitly even when+the kind variable is also used as a type variable. Thus, we must prefer to keep+a variable listed as a kind var in rmDupsInRdrTyVars. If we kept it as a type+var, then this would prevent it from being implicitly quantified (see+rnImplicitBndrs). In the `foo` example above, that would have the consequence+of the k in Proxy k being reported as out of scope.+ -} +-- See Note [Kind and type-variable binders] data FreeKiTyVars = FKTV { fktv_kis :: [Located RdrName] , fktv_tys :: [Located RdrName] } +-- | A 'FreeKiTyVars' list that is allowed to have duplicate variables.+type FreeKiTyVarsWithDups = FreeKiTyVars++-- | A 'FreeKiTyVars' list that contains no duplicate variables.+type FreeKiTyVarsNoDups = FreeKiTyVars+ instance Outputable FreeKiTyVars where ppr (FKTV kis tys) = ppr (kis, tys) -emptyFKTV :: FreeKiTyVars+emptyFKTV :: FreeKiTyVarsNoDups emptyFKTV = FKTV [] [] freeKiTyVarsAllVars :: FreeKiTyVars -> [Located RdrName]@@ -1555,48 +1642,82 @@ inScope :: LocalRdrEnv -> RdrName -> Bool inScope rdr_env rdr = rdr `elemLocalRdrEnv` rdr_env -extractHsTyRdrTyVars :: LHsType RdrName -> RnM FreeKiTyVars--- extractHsTyRdrNames finds the free (kind, type) variables of a HsType--- or the free (sort, kind) variables of a HsKind--- It's used when making the for-alls explicit.--- Does not return any wildcards+-- | 'extractHsTyRdrTyVars' finds the+-- free (kind, type) variables of an 'HsType'+-- or the free (sort, kind) variables of an 'HsKind'.+-- It's used when making the @forall@s explicit.+-- Does not return any wildcards. -- When the same name occurs multiple times in the types, only the first -- occurrence is returned. -- See Note [Kind and type-variable binders]+extractHsTyRdrTyVars :: LHsType GhcPs -> RnM FreeKiTyVarsNoDups extractHsTyRdrTyVars ty- = do { FKTV kis tys <- extract_lty TypeLevel ty emptyFKTV- ; return (FKTV (nubL kis)- (nubL tys)) }+ = rmDupsInRdrTyVars <$> extractHsTyRdrTyVarsDups ty +-- | 'extractHsTyRdrTyVarsDups' find the+-- free (kind, type) variables of an 'HsType'+-- or the free (sort, kind) variables of an 'HsKind'.+-- It's used when making the @forall@s explicit.+-- Does not return any wildcards.+-- When the same name occurs multiple times in the types, all occurrences+-- are returned.+extractHsTyRdrTyVarsDups :: LHsType GhcPs -> RnM FreeKiTyVarsWithDups+extractHsTyRdrTyVarsDups ty+ = extract_lty TypeLevel ty emptyFKTV +-- | Extracts the free kind variables (but not the type variables) of an+-- 'HsType'. Does not return any wildcards.+-- When the same name occurs multiple times in the type, only the first+-- occurrence is returned.+-- See Note [Kind and type-variable binders]+extractHsTyRdrTyVarsKindVars :: LHsType GhcPs -> RnM [Located RdrName]+extractHsTyRdrTyVarsKindVars ty+ = freeKiTyVarsKindVars <$> extractHsTyRdrTyVars ty+ -- | Extracts free type and kind variables from types in a list. -- When the same name occurs multiple times in the types, only the first -- occurrence is returned and the rest is filtered out. -- See Note [Kind and type-variable binders]-extractHsTysRdrTyVars :: [LHsType RdrName] -> RnM FreeKiTyVars+extractHsTysRdrTyVars :: [LHsType GhcPs] -> RnM FreeKiTyVarsNoDups extractHsTysRdrTyVars tys = rmDupsInRdrTyVars <$> extractHsTysRdrTyVarsDups tys -- | Extracts free type and kind variables from types in a list. -- When the same name occurs multiple times in the types, all occurrences -- are returned.-extractHsTysRdrTyVarsDups :: [LHsType RdrName] -> RnM FreeKiTyVars+extractHsTysRdrTyVarsDups :: [LHsType GhcPs] -> RnM FreeKiTyVarsWithDups extractHsTysRdrTyVarsDups tys = extract_ltys TypeLevel tys emptyFKTV --- | Removes multiple occurrences of the same name from FreeKiTyVars.-rmDupsInRdrTyVars :: FreeKiTyVars -> FreeKiTyVars+extractHsTyVarBndrsKVs :: [LHsTyVarBndr GhcPs] -> RnM [Located RdrName]+-- Returns the free kind variables of any explictly-kinded binders+-- NB: Does /not/ delete the binders themselves.+-- However duplicates are removed+-- E.g. given [k1, a:k1, b:k2]+-- the function returns [k1,k2], even though k1 is bound here+extractHsTyVarBndrsKVs tv_bndrs+ = do { kvs <- extract_hs_tv_bndrs_kvs tv_bndrs+ ; return (nubL kvs) }++-- | Removes multiple occurrences of the same name from FreeKiTyVars. If a+-- variable occurs as both a kind and a type variable, only keep the occurrence+-- as a kind variable.+-- See also Note [Kind and type-variable binders]+rmDupsInRdrTyVars :: FreeKiTyVarsWithDups -> FreeKiTyVarsNoDups rmDupsInRdrTyVars (FKTV kis tys)- = FKTV (nubL kis) (nubL tys)+ = FKTV kis' tys'+ where+ kis' = nubL kis+ tys' = nubL (filterOut (`elemRdr` kis') tys) -extractRdrKindSigVars :: LFamilyResultSig RdrName -> RnM [Located RdrName]+extractRdrKindSigVars :: LFamilyResultSig GhcPs -> RnM [Located RdrName] extractRdrKindSigVars (L _ resultSig) | KindSig k <- resultSig = kindRdrNameFromSig k | TyVarSig (L _ (KindedTyVar _ k)) <- resultSig = kindRdrNameFromSig k | otherwise = return [] where kindRdrNameFromSig k = freeKiTyVarsAllVars <$> extractHsTyRdrTyVars k -extractDataDefnKindVars :: HsDataDefn RdrName -> RnM [Located RdrName]+extractDataDefnKindVars :: HsDataDefn GhcPs -> RnM [Located RdrName] -- Get the scoped kind variables mentioned free in the constructor decls -- Eg: data T a = T1 (S (a :: k) | forall (b::k). T2 (S b) -- Here k should scope over the whole definition@@ -1624,16 +1745,16 @@ extract_mlctxt ctxt =<< extract_ltys TypeLevel (hsConDeclArgTys details) emptyFKTV -extract_mlctxt :: Maybe (LHsContext RdrName) -> FreeKiTyVars -> RnM FreeKiTyVars+extract_mlctxt :: Maybe (LHsContext GhcPs) -> FreeKiTyVars -> RnM FreeKiTyVars extract_mlctxt Nothing acc = return acc extract_mlctxt (Just ctxt) acc = extract_lctxt TypeLevel ctxt acc extract_lctxt :: TypeOrKind- -> LHsContext RdrName -> FreeKiTyVars -> RnM FreeKiTyVars+ -> LHsContext GhcPs -> FreeKiTyVars -> RnM FreeKiTyVars extract_lctxt t_or_k ctxt = extract_ltys t_or_k (unLoc ctxt) extract_ltys :: TypeOrKind- -> [LHsType RdrName] -> FreeKiTyVars -> RnM FreeKiTyVars+ -> [LHsType GhcPs] -> FreeKiTyVars -> RnM FreeKiTyVars extract_ltys t_or_k tys acc = foldrM (extract_lty t_or_k) acc tys extract_mb :: (a -> FreeKiTyVars -> RnM FreeKiTyVars)@@ -1641,10 +1762,10 @@ extract_mb _ Nothing acc = return acc extract_mb f (Just x) acc = f x acc -extract_lkind :: LHsType RdrName -> FreeKiTyVars -> RnM FreeKiTyVars+extract_lkind :: LHsType GhcPs -> FreeKiTyVars -> RnM FreeKiTyVars extract_lkind = extract_lty KindLevel -extract_lty :: TypeOrKind -> LHsType RdrName -> FreeKiTyVars -> RnM FreeKiTyVars+extract_lty :: TypeOrKind -> LHsType GhcPs -> FreeKiTyVars -> RnM FreeKiTyVars extract_lty t_or_k (L _ ty) acc = case ty of HsTyVar _ ltv -> extract_tv t_or_k ltv acc@@ -1686,61 +1807,90 @@ HsWildCardTy {} -> return acc extract_apps :: TypeOrKind- -> [LHsAppType RdrName] -> FreeKiTyVars -> RnM FreeKiTyVars+ -> [LHsAppType GhcPs] -> FreeKiTyVars -> RnM FreeKiTyVars extract_apps t_or_k tys acc = foldrM (extract_app t_or_k) acc tys -extract_app :: TypeOrKind -> LHsAppType RdrName -> FreeKiTyVars+extract_app :: TypeOrKind -> LHsAppType GhcPs -> FreeKiTyVars -> RnM FreeKiTyVars extract_app t_or_k (L _ (HsAppInfix tv)) acc = extract_tv t_or_k tv acc extract_app t_or_k (L _ (HsAppPrefix ty)) acc = extract_lty t_or_k ty acc -extract_hs_tv_bndrs :: [LHsTyVarBndr RdrName] -> FreeKiTyVars+extract_hs_tv_bndrs :: [LHsTyVarBndr GhcPs] -> FreeKiTyVars -> FreeKiTyVars -> RnM FreeKiTyVars -- In (forall (a :: Maybe e). a -> b) we have -- 'a' is bound by the forall -- 'b' is a free type variable -- 'e' is a free kind variable-extract_hs_tv_bndrs tvs- (FKTV acc_kvs acc_tvs)- -- Note accumulator comes first- (FKTV body_kvs body_tvs)- | null tvs+extract_hs_tv_bndrs tv_bndrs+ (FKTV acc_kvs acc_tvs) -- Accumulator+ (FKTV body_kvs body_tvs) -- Free in the body+ | null tv_bndrs = return $ FKTV (body_kvs ++ acc_kvs) (body_tvs ++ acc_tvs) | otherwise- = do { FKTV bndr_kvs _- <- foldrM extract_lkind emptyFKTV [k | L _ (KindedTyVar _ k) <- tvs]+ = do { bndr_kvs <- extract_hs_tv_bndrs_kvs tv_bndrs - ; let locals = map hsLTyVarName tvs+ ; let tv_bndr_rdrs :: [Located RdrName]+ tv_bndr_rdrs = map hsLTyVarLocName tv_bndrs++ ; traceRn "checkMixedVars1" $+ vcat [ text "body_kvs" <+> ppr body_kvs+ , text "tv_bndr_rdrs" <+> ppr tv_bndr_rdrs ]+ ; checkMixedVars body_kvs tv_bndr_rdrs+ ; return $- FKTV (filterOut ((`elem` locals) . unLoc) (bndr_kvs ++ body_kvs)+ FKTV (filterOut (`elemRdr` tv_bndr_rdrs) (bndr_kvs ++ body_kvs)+ -- NB: delete all tv_bndr_rdrs from bndr_kvs as well+ -- as body_kvs; see Note [Kind variable scoping] ++ acc_kvs)- (filterOut ((`elem` locals) . unLoc) body_tvs ++ acc_tvs) }+ (filterOut (`elemRdr` tv_bndr_rdrs) body_tvs ++ acc_tvs) } -extract_tv :: TypeOrKind -> Located RdrName -> FreeKiTyVars -> RnM FreeKiTyVars-extract_tv t_or_k ltv@(L _ tv) acc- | isRdrTyVar tv = case acc of- FKTV kvs tvs- | isTypeLevel t_or_k- -> do { when (ltv `elemRdr` kvs) $- mixedVarsErr ltv- ; return (FKTV kvs (ltv : tvs)) }- | otherwise- -> do { when (ltv `elemRdr` tvs) $- mixedVarsErr ltv- ; return (FKTV (ltv : kvs) tvs) }- | otherwise = return acc- where- elemRdr x = any (eqLocated x)+extract_hs_tv_bndrs_kvs :: [LHsTyVarBndr GhcPs] -> RnM [Located RdrName]+-- Returns the free kind variables of any explictly-kinded binders+-- NB: Does /not/ delete the binders themselves.+-- Duplicates are /not/ removed+-- E.g. given [k1, a:k1, b:k2]+-- the function returns [k1,k2], even though k1 is bound here+extract_hs_tv_bndrs_kvs tv_bndrs+ = do { fktvs <- foldrM extract_lkind emptyFKTV+ [k | L _ (KindedTyVar _ k) <- tv_bndrs]+ ; return (freeKiTyVarsKindVars fktvs) }+ -- There will /be/ no free tyvars! -mixedVarsErr :: Located RdrName -> RnM ()-mixedVarsErr (L loc tv)- = do { typeintype <- xoptM LangExt.TypeInType- ; unless typeintype $- addErrAt loc $ text "Variable" <+> quotes (ppr tv) <+>- text "used as both a kind and a type" $$- text "Did you intend to use TypeInType?" }+extract_tv :: TypeOrKind -> Located RdrName -> FreeKiTyVars+ -> RnM FreeKiTyVars+extract_tv t_or_k ltv@(L _ tv) acc@(FKTV kvs tvs)+ | not (isRdrTyVar tv) = return acc+ | isTypeLevel t_or_k = return (FKTV kvs (ltv : tvs))+ | otherwise = return (FKTV (ltv : kvs) tvs) -- just used in this module; seemed convenient here nubL :: Eq a => [Located a] -> [Located a] nubL = nubBy eqLocated++elemRdr :: Located RdrName -> [Located RdrName] -> Bool+elemRdr x = any (eqLocated x)++checkMixedVars :: [Located RdrName] -> [Located RdrName] -> RnM ()+-- In (checkMixedVars kvs tvs) we are about to bind the type+-- variables tvs, and kvs is the set of free variables of the kinds+-- in the scope of the binding. E.g.+-- forall a b. a -> (b::k) -> (c::a)+-- Here tv will be {a,b}, and kvs {k,a}.+-- Without -XTypeInType we want to complain that 'a' is used both+-- as a type and a kind.+--+-- Specifically, check that there is no overlap between kvs and tvs+-- See typecheck/should_fail/T11963 for examples+--+-- NB: we do this only at the binding site of 'tvs'.+checkMixedVars kvs tvs+ = do { type_in_type <- xoptM LangExt.TypeInType+ ; unless type_in_type $+ mapM_ check kvs }+ where+ check kv = when (kv `elemRdr` tvs) $+ addErrAt (getLoc kv) $+ vcat [ text "Variable" <+> quotes (ppr kv)+ <+> text "used as both a kind and a type"+ , text "Did you intend to use TypeInType?" ]
+ rename/RnUnbound.hs view
@@ -0,0 +1,342 @@+{-++This module contains helper functions for reporting and creating+unbound variables.++-}+module RnUnbound ( mkUnboundName+ , mkUnboundNameRdr+ , isUnboundName+ , reportUnboundName+ , unknownNameSuggestions+ , WhereLooking(..)+ , unboundName+ , unboundNameX+ , perhapsForallMsg ) where++import GhcPrelude++import RdrName+import HscTypes+import TcRnMonad+import Name+import Module+import SrcLoc+import Outputable+import PrelNames ( mkUnboundName, forall_tv_RDR, isUnboundName )+import Util+import Maybes+import DynFlags+import FastString+import Data.List+import Data.Function ( on )++{-+************************************************************************+* *+ What to do when a lookup fails+* *+************************************************************************+-}++data WhereLooking = WL_Any -- Any binding+ | WL_Global -- Any top-level binding (local or imported)+ | WL_LocalTop -- Any top-level binding in this module+ | WL_LocalOnly+ -- Only local bindings+ -- (pattern synonyms declaractions,+ -- see Note [Renaming pattern synonym variables])++mkUnboundNameRdr :: RdrName -> Name+mkUnboundNameRdr rdr = mkUnboundName (rdrNameOcc rdr)++reportUnboundName :: RdrName -> RnM Name+reportUnboundName rdr = unboundName WL_Any rdr++unboundName :: WhereLooking -> RdrName -> RnM Name+unboundName wl rdr = unboundNameX wl rdr Outputable.empty++unboundNameX :: WhereLooking -> RdrName -> SDoc -> RnM Name+unboundNameX where_look rdr_name extra+ = do { dflags <- getDynFlags+ ; let show_helpful_errors = gopt Opt_HelpfulErrors dflags+ what = pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))+ err = unknownNameErr what rdr_name $$ extra+ ; if not show_helpful_errors+ then addErr err+ else do { local_env <- getLocalRdrEnv+ ; global_env <- getGlobalRdrEnv+ ; impInfo <- getImports+ ; let suggestions = unknownNameSuggestions_ where_look+ dflags global_env local_env impInfo rdr_name+ ; addErr (err $$ suggestions) }+ ; return (mkUnboundNameRdr rdr_name) }++unknownNameErr :: SDoc -> RdrName -> SDoc+unknownNameErr what rdr_name+ = vcat [ hang (text "Not in scope:")+ 2 (what <+> quotes (ppr rdr_name))+ , extra ]+ where+ extra | rdr_name == forall_tv_RDR = perhapsForallMsg+ | otherwise = Outputable.empty++type HowInScope = Either SrcSpan ImpDeclSpec+ -- Left loc => locally bound at loc+ -- Right ispec => imported as specified by ispec+++-- | Called from the typechecker (TcErrors) when we find an unbound variable+unknownNameSuggestions :: DynFlags+ -> GlobalRdrEnv -> LocalRdrEnv -> ImportAvails+ -> RdrName -> SDoc+unknownNameSuggestions = unknownNameSuggestions_ WL_Any++unknownNameSuggestions_ :: WhereLooking -> DynFlags+ -> GlobalRdrEnv -> LocalRdrEnv -> ImportAvails+ -> RdrName -> SDoc+unknownNameSuggestions_ where_look dflags global_env local_env imports tried_rdr_name =+ similarNameSuggestions where_look dflags global_env local_env tried_rdr_name $$+ importSuggestions where_look imports tried_rdr_name $$+ extensionSuggestions tried_rdr_name+++similarNameSuggestions :: WhereLooking -> DynFlags+ -> GlobalRdrEnv -> LocalRdrEnv+ -> RdrName -> SDoc+similarNameSuggestions where_look dflags global_env+ local_env tried_rdr_name+ = case suggest of+ [] -> Outputable.empty+ [p] -> perhaps <+> pp_item p+ ps -> sep [ perhaps <+> text "one of these:"+ , nest 2 (pprWithCommas pp_item ps) ]+ where+ all_possibilities :: [(String, (RdrName, HowInScope))]+ all_possibilities+ = [ (showPpr dflags r, (r, Left loc))+ | (r,loc) <- local_possibilities local_env ]+ ++ [ (showPpr dflags r, rp) | (r, rp) <- global_possibilities global_env ]++ suggest = fuzzyLookup (showPpr dflags tried_rdr_name) all_possibilities+ perhaps = text "Perhaps you meant"++ pp_item :: (RdrName, HowInScope) -> SDoc+ pp_item (rdr, Left loc) = pp_ns rdr <+> quotes (ppr rdr) <+> loc' -- Locally defined+ where loc' = case loc of+ UnhelpfulSpan l -> parens (ppr l)+ RealSrcSpan l -> parens (text "line" <+> int (srcSpanStartLine l))+ pp_item (rdr, Right is) = pp_ns rdr <+> quotes (ppr rdr) <+> -- Imported+ parens (text "imported from" <+> ppr (is_mod is))++ pp_ns :: RdrName -> SDoc+ pp_ns rdr | ns /= tried_ns = pprNameSpace ns+ | otherwise = Outputable.empty+ where ns = rdrNameSpace rdr++ tried_occ = rdrNameOcc tried_rdr_name+ tried_is_sym = isSymOcc tried_occ+ tried_ns = occNameSpace tried_occ+ tried_is_qual = isQual tried_rdr_name++ correct_name_space occ = nameSpacesRelated (occNameSpace occ) tried_ns+ && isSymOcc occ == tried_is_sym+ -- Treat operator and non-operators as non-matching+ -- This heuristic avoids things like+ -- Not in scope 'f'; perhaps you meant '+' (from Prelude)++ local_ok = case where_look of { WL_Any -> True+ ; WL_LocalOnly -> True+ ; _ -> False }+ local_possibilities :: LocalRdrEnv -> [(RdrName, SrcSpan)]+ local_possibilities env+ | tried_is_qual = []+ | not local_ok = []+ | otherwise = [ (mkRdrUnqual occ, nameSrcSpan name)+ | name <- localRdrEnvElts env+ , let occ = nameOccName name+ , correct_name_space occ]++ gre_ok :: GlobalRdrElt -> Bool+ gre_ok = case where_look of+ WL_LocalTop -> isLocalGRE+ WL_LocalOnly -> const False+ _ -> const True++ global_possibilities :: GlobalRdrEnv -> [(RdrName, (RdrName, HowInScope))]+ global_possibilities global_env+ | tried_is_qual = [ (rdr_qual, (rdr_qual, how))+ | gre <- globalRdrEnvElts global_env+ , gre_ok gre+ , let name = gre_name gre+ occ = nameOccName name+ , correct_name_space occ+ , (mod, how) <- quals_in_scope gre+ , let rdr_qual = mkRdrQual mod occ ]++ | otherwise = [ (rdr_unqual, pair)+ | gre <- globalRdrEnvElts global_env+ , gre_ok gre+ , let name = gre_name gre+ occ = nameOccName name+ rdr_unqual = mkRdrUnqual occ+ , correct_name_space occ+ , pair <- case (unquals_in_scope gre, quals_only gre) of+ (how:_, _) -> [ (rdr_unqual, how) ]+ ([], pr:_) -> [ pr ] -- See Note [Only-quals]+ ([], []) -> [] ]++ -- Note [Only-quals]+ -- The second alternative returns those names with the same+ -- OccName as the one we tried, but live in *qualified* imports+ -- e.g. if you have:+ --+ -- > import qualified Data.Map as Map+ -- > foo :: Map+ --+ -- then we suggest @Map.Map@.++ --------------------+ unquals_in_scope :: GlobalRdrElt -> [HowInScope]+ unquals_in_scope (GRE { gre_name = n, gre_lcl = lcl, gre_imp = is })+ | lcl = [ Left (nameSrcSpan n) ]+ | otherwise = [ Right ispec+ | i <- is, let ispec = is_decl i+ , not (is_qual ispec) ]++ --------------------+ quals_in_scope :: GlobalRdrElt -> [(ModuleName, HowInScope)]+ -- Ones for which the qualified version is in scope+ quals_in_scope (GRE { gre_name = n, gre_lcl = lcl, gre_imp = is })+ | lcl = case nameModule_maybe n of+ Nothing -> []+ Just m -> [(moduleName m, Left (nameSrcSpan n))]+ | otherwise = [ (is_as ispec, Right ispec)+ | i <- is, let ispec = is_decl i ]++ --------------------+ quals_only :: GlobalRdrElt -> [(RdrName, HowInScope)]+ -- Ones for which *only* the qualified version is in scope+ quals_only (GRE { gre_name = n, gre_imp = is })+ = [ (mkRdrQual (is_as ispec) (nameOccName n), Right ispec)+ | i <- is, let ispec = is_decl i, is_qual ispec ]++-- | Generate helpful suggestions if a qualified name Mod.foo is not in scope.+importSuggestions :: WhereLooking -> ImportAvails -> RdrName -> SDoc+importSuggestions where_look imports rdr_name+ | WL_LocalOnly <- where_look = Outputable.empty+ | not (isQual rdr_name || isUnqual rdr_name) = Outputable.empty+ | null interesting_imports+ , Just name <- mod_name+ = hsep+ [ text "No module named"+ , quotes (ppr name)+ , text "is imported."+ ]+ | is_qualified+ , null helpful_imports+ , [(mod,_)] <- interesting_imports+ = hsep+ [ text "Module"+ , quotes (ppr mod)+ , text "does not export"+ , quotes (ppr occ_name) <> dot+ ]+ | is_qualified+ , null helpful_imports+ , mods <- map fst interesting_imports+ = hsep+ [ text "Neither"+ , quotedListWithNor (map ppr mods)+ , text "exports"+ , quotes (ppr occ_name) <> dot+ ]+ | [(mod,imv)] <- helpful_imports_non_hiding+ = fsep+ [ text "Perhaps you want to add"+ , quotes (ppr occ_name)+ , text "to the import list"+ , text "in the import of"+ , quotes (ppr mod)+ , parens (ppr (imv_span imv)) <> dot+ ]+ | not (null helpful_imports_non_hiding)+ = fsep+ [ text "Perhaps you want to add"+ , quotes (ppr occ_name)+ , text "to one of these import lists:"+ ]+ $$+ nest 2 (vcat+ [ quotes (ppr mod) <+> parens (ppr (imv_span imv))+ | (mod,imv) <- helpful_imports_non_hiding+ ])+ | [(mod,imv)] <- helpful_imports_hiding+ = fsep+ [ text "Perhaps you want to remove"+ , quotes (ppr occ_name)+ , text "from the explicit hiding list"+ , text "in the import of"+ , quotes (ppr mod)+ , parens (ppr (imv_span imv)) <> dot+ ]+ | not (null helpful_imports_hiding)+ = fsep+ [ text "Perhaps you want to remove"+ , quotes (ppr occ_name)+ , text "from the hiding clauses"+ , text "in one of these imports:"+ ]+ $$+ nest 2 (vcat+ [ quotes (ppr mod) <+> parens (ppr (imv_span imv))+ | (mod,imv) <- helpful_imports_hiding+ ])+ | otherwise+ = Outputable.empty+ where+ is_qualified = isQual rdr_name+ (mod_name, occ_name) = case rdr_name of+ Unqual occ_name -> (Nothing, occ_name)+ Qual mod_name occ_name -> (Just mod_name, occ_name)+ _ -> error "importSuggestions: dead code"+++ -- What import statements provide "Mod" at all+ -- or, if this is an unqualified name, are not qualified imports+ interesting_imports = [ (mod, imp)+ | (mod, mod_imports) <- moduleEnvToList (imp_mods imports)+ , Just imp <- return $ pick (importedByUser mod_imports)+ ]++ -- We want to keep only one for each original module; preferably one with an+ -- explicit import list (for no particularly good reason)+ pick :: [ImportedModsVal] -> Maybe ImportedModsVal+ pick = listToMaybe . sortBy (compare `on` prefer) . filter select+ where select imv = case mod_name of Just name -> imv_name imv == name+ Nothing -> not (imv_qualified imv)+ prefer imv = (imv_is_hiding imv, imv_span imv)++ -- Which of these would export a 'foo'+ -- (all of these are restricted imports, because if they were not, we+ -- wouldn't have an out-of-scope error in the first place)+ helpful_imports = filter helpful interesting_imports+ where helpful (_,imv)+ = not . null $ lookupGlobalRdrEnv (imv_all_exports imv) occ_name++ -- Which of these do that because of an explicit hiding list resp. an+ -- explicit import list+ (helpful_imports_hiding, helpful_imports_non_hiding)+ = partition (imv_is_hiding . snd) helpful_imports++extensionSuggestions :: RdrName -> SDoc+extensionSuggestions rdrName+ | rdrName == mkUnqual varName (fsLit "mdo") ||+ rdrName == mkUnqual varName (fsLit "rec")+ = text "Perhaps you meant to use RecursiveDo"+ | otherwise = Outputable.empty++perhapsForallMsg :: SDoc+perhapsForallMsg+ = vcat [ text "Perhaps you intended to use ExplicitForAll or similar flag"+ , text "to enable explicit-forall syntax: forall <tvs>. <type>"]
+ rename/RnUtils.hs view
@@ -0,0 +1,413 @@+{-++This module contains miscellaneous functions related to renaming.++-}+module RnUtils (+ checkDupRdrNames, checkShadowedRdrNames,+ checkDupNames, checkDupAndShadowedNames, dupNamesErr,+ checkTupSize,+ addFvRn, mapFvRn, mapMaybeFvRn,+ warnUnusedMatches, warnUnusedTypePatterns,+ warnUnusedTopBinds, warnUnusedLocalBinds,+ mkFieldEnv,+ unknownSubordinateErr, badQualBndrErr,+ HsDocContext(..), pprHsDocContext,+ inHsDocContext, withHsDocContext,++ newLocalBndrRn, newLocalBndrsRn,++ bindLocalNames, bindLocalNamesFV,++ addNameClashErrRn, extendTyVarEnvFVRn++)++where+++import GhcPrelude++import HsSyn+import RdrName+import HscTypes+import TcEnv+import TcRnMonad+import Name+import NameSet+import NameEnv+import DataCon+import SrcLoc+import Outputable+import Util+import BasicTypes ( TopLevelFlag(..) )+import ListSetOps ( removeDups )+import DynFlags+import FastString+import Control.Monad+import Data.List+import Constants ( mAX_TUPLE_SIZE )+import qualified Data.List.NonEmpty as NE+import qualified GHC.LanguageExtensions as LangExt++{-+*********************************************************+* *+\subsection{Binding}+* *+*********************************************************+-}++newLocalBndrRn :: Located RdrName -> RnM Name+-- Used for non-top-level binders. These should+-- never be qualified.+newLocalBndrRn (L loc rdr_name)+ | Just name <- isExact_maybe rdr_name+ = return name -- This happens in code generated by Template Haskell+ -- See Note [Binders in Template Haskell] in Convert.hs+ | otherwise+ = do { unless (isUnqual rdr_name)+ (addErrAt loc (badQualBndrErr rdr_name))+ ; uniq <- newUnique+ ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }++newLocalBndrsRn :: [Located RdrName] -> RnM [Name]+newLocalBndrsRn = mapM newLocalBndrRn++bindLocalNames :: [Name] -> RnM a -> RnM a+bindLocalNames names enclosed_scope+ = do { lcl_env <- getLclEnv+ ; let th_level = thLevel (tcl_th_ctxt lcl_env)+ th_bndrs' = extendNameEnvList (tcl_th_bndrs lcl_env)+ [ (n, (NotTopLevel, th_level)) | n <- names ]+ rdr_env' = extendLocalRdrEnvList (tcl_rdr lcl_env) names+ ; setLclEnv (lcl_env { tcl_th_bndrs = th_bndrs'+ , tcl_rdr = rdr_env' })+ enclosed_scope }++bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)+bindLocalNamesFV names enclosed_scope+ = do { (result, fvs) <- bindLocalNames names enclosed_scope+ ; return (result, delFVs names fvs) }++-------------------------------------++extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)+extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside++-------------------------------------+checkDupRdrNames :: [Located RdrName] -> RnM ()+-- Check for duplicated names in a binding group+checkDupRdrNames rdr_names_w_loc+ = mapM_ (dupNamesErr getLoc) dups+ where+ (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc++checkDupNames :: [Name] -> RnM ()+-- Check for duplicated names in a binding group+checkDupNames names = check_dup_names (filterOut isSystemName names)+ -- See Note [Binders in Template Haskell] in Convert++check_dup_names :: [Name] -> RnM ()+check_dup_names names+ = mapM_ (dupNamesErr nameSrcSpan) dups+ where+ (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names++---------------------+checkShadowedRdrNames :: [Located RdrName] -> RnM ()+checkShadowedRdrNames loc_rdr_names+ = do { envs <- getRdrEnvs+ ; checkShadowedOccs envs get_loc_occ filtered_rdrs }+ where+ filtered_rdrs = filterOut (isExact . unLoc) loc_rdr_names+ -- See Note [Binders in Template Haskell] in Convert+ get_loc_occ (L loc rdr) = (loc,rdrNameOcc rdr)++checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()+checkDupAndShadowedNames envs names+ = do { check_dup_names filtered_names+ ; checkShadowedOccs envs get_loc_occ filtered_names }+ where+ filtered_names = filterOut isSystemName names+ -- See Note [Binders in Template Haskell] in Convert+ get_loc_occ name = (nameSrcSpan name, nameOccName name)++-------------------------------------+checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv)+ -> (a -> (SrcSpan, OccName))+ -> [a] -> RnM ()+checkShadowedOccs (global_env,local_env) get_loc_occ ns+ = whenWOptM Opt_WarnNameShadowing $+ do { traceRn "checkShadowedOccs:shadow" (ppr (map get_loc_occ ns))+ ; mapM_ check_shadow ns }+ where+ check_shadow n+ | startsWithUnderscore occ = return () -- Do not report shadowing for "_x"+ -- See Trac #3262+ | Just n <- mb_local = complain [text "bound at" <+> ppr (nameSrcLoc n)]+ | otherwise = do { gres' <- filterM is_shadowed_gre gres+ ; complain (map pprNameProvenance gres') }+ where+ (loc,occ) = get_loc_occ n+ mb_local = lookupLocalRdrOcc local_env occ+ gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env+ -- Make an Unqualified RdrName and look that up, so that+ -- we don't find any GREs that are in scope qualified-only++ complain [] = return ()+ complain pp_locs = addWarnAt (Reason Opt_WarnNameShadowing)+ loc+ (shadowedNameWarn occ pp_locs)++ is_shadowed_gre :: GlobalRdrElt -> RnM Bool+ -- Returns False for record selectors that are shadowed, when+ -- punning or wild-cards are on (cf Trac #2723)+ is_shadowed_gre gre | isRecFldGRE gre+ = do { dflags <- getDynFlags+ ; return $ not (xopt LangExt.RecordPuns dflags+ || xopt LangExt.RecordWildCards dflags) }+ is_shadowed_gre _other = return True+++{-+************************************************************************+* *+\subsection{Free variable manipulation}+* *+************************************************************************+-}++-- A useful utility+addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)+addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside+ ; return (res, fvs1 `plusFV` fvs2) }++mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)+mapFvRn f xs = do stuff <- mapM f xs+ case unzip stuff of+ (ys, fvs_s) -> return (ys, plusFVs fvs_s)++mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)+mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)+mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }++{-+************************************************************************+* *+\subsection{Envt utility functions}+* *+************************************************************************+-}++warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()+warnUnusedTopBinds gres+ = whenWOptM Opt_WarnUnusedTopBinds+ $ do env <- getGblEnv+ let isBoot = tcg_src env == HsBootFile+ let noParent gre = case gre_par gre of+ NoParent -> True+ _ -> False+ -- Don't warn about unused bindings with parents in+ -- .hs-boot files, as you are sometimes required to give+ -- unused bindings (trac #3449).+ -- HOWEVER, in a signature file, you are never obligated to put a+ -- definition in the main text. Thus, if you define something+ -- and forget to export it, we really DO want to warn.+ gres' = if isBoot then filter noParent gres+ else gres+ warnUnusedGREs gres'++warnUnusedLocalBinds, warnUnusedMatches, warnUnusedTypePatterns+ :: [Name] -> FreeVars -> RnM ()+warnUnusedLocalBinds = check_unused Opt_WarnUnusedLocalBinds+warnUnusedMatches = check_unused Opt_WarnUnusedMatches+warnUnusedTypePatterns = check_unused Opt_WarnUnusedTypePatterns++check_unused :: WarningFlag -> [Name] -> FreeVars -> RnM ()+check_unused flag bound_names used_names+ = whenWOptM flag (warnUnused flag (filterOut (`elemNameSet` used_names)+ bound_names))++-------------------------+-- Helpers+warnUnusedGREs :: [GlobalRdrElt] -> RnM ()+warnUnusedGREs gres = mapM_ warnUnusedGRE gres++warnUnused :: WarningFlag -> [Name] -> RnM ()+warnUnused flag names = do+ fld_env <- mkFieldEnv <$> getGlobalRdrEnv+ mapM_ (warnUnused1 flag fld_env) names++warnUnused1 :: WarningFlag -> NameEnv (FieldLabelString, Name) -> Name -> RnM ()+warnUnused1 flag fld_env name+ = when (reportable name occ) $+ addUnusedWarning flag+ occ (nameSrcSpan name)+ (text "Defined but not used")+ where+ occ = case lookupNameEnv fld_env name of+ Just (fl, _) -> mkVarOccFS fl+ Nothing -> nameOccName name++warnUnusedGRE :: GlobalRdrElt -> RnM ()+warnUnusedGRE gre@(GRE { gre_name = name, gre_lcl = lcl, gre_imp = is })+ | lcl = do fld_env <- mkFieldEnv <$> getGlobalRdrEnv+ warnUnused1 Opt_WarnUnusedTopBinds fld_env name+ | otherwise = when (reportable name occ) (mapM_ warn is)+ where+ occ = greOccName gre+ warn spec = addUnusedWarning Opt_WarnUnusedTopBinds occ span msg+ where+ span = importSpecLoc spec+ pp_mod = quotes (ppr (importSpecModule spec))+ msg = text "Imported from" <+> pp_mod <+> ptext (sLit "but not used")++-- | Make a map from selector names to field labels and parent tycon+-- names, to be used when reporting unused record fields.+mkFieldEnv :: GlobalRdrEnv -> NameEnv (FieldLabelString, Name)+mkFieldEnv rdr_env = mkNameEnv [ (gre_name gre, (lbl, par_is (gre_par gre)))+ | gres <- occEnvElts rdr_env+ , gre <- gres+ , Just lbl <- [greLabel gre]+ ]++-- | Should we report the fact that this 'Name' is unused? The+-- 'OccName' may differ from 'nameOccName' due to+-- DuplicateRecordFields.+reportable :: Name -> OccName -> Bool+reportable name occ+ | isWiredInName name = False -- Don't report unused wired-in names+ -- Otherwise we get a zillion warnings+ -- from Data.Tuple+ | otherwise = not (startsWithUnderscore occ)++addUnusedWarning :: WarningFlag -> OccName -> SrcSpan -> SDoc -> RnM ()+addUnusedWarning flag occ span msg+ = addWarnAt (Reason flag) span $+ sep [msg <> colon,+ nest 2 $ pprNonVarNameSpace (occNameSpace occ)+ <+> quotes (ppr occ)]++addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()+addNameClashErrRn rdr_name gres+ | all isLocalGRE gres && not (all isRecFldGRE gres)+ -- If there are two or more *local* defns, we'll have reported+ = return () -- that already, and we don't want an error cascade+ | otherwise+ = addErr (vcat [text "Ambiguous occurrence" <+> quotes (ppr rdr_name),+ text "It could refer to" <+> vcat (msg1 : msgs)])+ where+ (np1:nps) = gres+ msg1 = ptext (sLit "either") <+> mk_ref np1+ msgs = [text " or" <+> mk_ref np | np <- nps]+ mk_ref gre = sep [nom <> comma, pprNameProvenance gre]+ where nom = case gre_par gre of+ FldParent { par_lbl = Just lbl } -> text "the field" <+> quotes (ppr lbl)+ _ -> quotes (ppr (gre_name gre))++shadowedNameWarn :: OccName -> [SDoc] -> SDoc+shadowedNameWarn occ shadowed_locs+ = sep [text "This binding for" <+> quotes (ppr occ)+ <+> text "shadows the existing binding" <> plural shadowed_locs,+ nest 2 (vcat shadowed_locs)]+++unknownSubordinateErr :: SDoc -> RdrName -> SDoc+unknownSubordinateErr doc op -- Doc is "method of class" or+ -- "field of constructor"+ = quotes (ppr op) <+> text "is not a (visible)" <+> doc+++dupNamesErr :: Outputable n => (n -> SrcSpan) -> NE.NonEmpty n -> RnM ()+dupNamesErr get_loc names+ = addErrAt big_loc $+ vcat [text "Conflicting definitions for" <+> quotes (ppr (NE.head names)),+ locations]+ where+ locs = map get_loc (NE.toList names)+ big_loc = foldr1 combineSrcSpans locs+ locations = text "Bound at:" <+> vcat (map ppr (sort locs))++badQualBndrErr :: RdrName -> SDoc+badQualBndrErr rdr_name+ = text "Qualified name in binding position:" <+> ppr rdr_name+++checkTupSize :: Int -> RnM ()+checkTupSize tup_size+ | tup_size <= mAX_TUPLE_SIZE+ = return ()+ | otherwise+ = addErr (sep [text "A" <+> int tup_size <> ptext (sLit "-tuple is too large for GHC"),+ nest 2 (parens (text "max size is" <+> int mAX_TUPLE_SIZE)),+ nest 2 (text "Workaround: use nested tuples or define a data type")])+++{-+************************************************************************+* *+\subsection{Contexts for renaming errors}+* *+************************************************************************+-}++-- AZ:TODO: Change these all to be Name instead of RdrName.+-- Merge TcType.UserTypeContext in to it.+data HsDocContext+ = TypeSigCtx SDoc+ | PatCtx+ | SpecInstSigCtx+ | DefaultDeclCtx+ | ForeignDeclCtx (Located RdrName)+ | DerivDeclCtx+ | RuleCtx FastString+ | TyDataCtx (Located RdrName)+ | TySynCtx (Located RdrName)+ | TyFamilyCtx (Located RdrName)+ | FamPatCtx (Located RdrName) -- The patterns of a type/data family instance+ | ConDeclCtx [Located Name]+ | ClassDeclCtx (Located RdrName)+ | ExprWithTySigCtx+ | TypBrCtx+ | HsTypeCtx+ | GHCiCtx+ | SpliceTypeCtx (LHsType GhcPs)+ | ClassInstanceCtx+ | VectDeclCtx (Located RdrName)+ | GenericCtx SDoc -- Maybe we want to use this more!++withHsDocContext :: HsDocContext -> SDoc -> SDoc+withHsDocContext ctxt doc = doc $$ inHsDocContext ctxt++inHsDocContext :: HsDocContext -> SDoc+inHsDocContext ctxt = text "In" <+> pprHsDocContext ctxt++pprHsDocContext :: HsDocContext -> SDoc+pprHsDocContext (GenericCtx doc) = doc+pprHsDocContext (TypeSigCtx doc) = text "the type signature for" <+> doc+pprHsDocContext PatCtx = text "a pattern type-signature"+pprHsDocContext SpecInstSigCtx = text "a SPECIALISE instance pragma"+pprHsDocContext DefaultDeclCtx = text "a `default' declaration"+pprHsDocContext DerivDeclCtx = text "a deriving declaration"+pprHsDocContext (RuleCtx name) = text "the transformation rule" <+> ftext name+pprHsDocContext (TyDataCtx tycon) = text "the data type declaration for" <+> quotes (ppr tycon)+pprHsDocContext (FamPatCtx tycon) = text "a type pattern of family instance for" <+> quotes (ppr tycon)+pprHsDocContext (TySynCtx name) = text "the declaration for type synonym" <+> quotes (ppr name)+pprHsDocContext (TyFamilyCtx name) = text "the declaration for type family" <+> quotes (ppr name)+pprHsDocContext (ClassDeclCtx name) = text "the declaration for class" <+> quotes (ppr name)+pprHsDocContext ExprWithTySigCtx = text "an expression type signature"+pprHsDocContext TypBrCtx = text "a Template-Haskell quoted type"+pprHsDocContext HsTypeCtx = text "a type argument"+pprHsDocContext GHCiCtx = text "GHCi input"+pprHsDocContext (SpliceTypeCtx hs_ty) = text "the spliced type" <+> quotes (ppr hs_ty)+pprHsDocContext ClassInstanceCtx = text "TcSplice.reifyInstances"++pprHsDocContext (ForeignDeclCtx name)+ = text "the foreign declaration for" <+> quotes (ppr name)+pprHsDocContext (ConDeclCtx [name])+ = text "the definition of data constructor" <+> quotes (ppr name)+pprHsDocContext (ConDeclCtx names)+ = text "the definition of data constructors" <+> interpp'SP names+pprHsDocContext (VectDeclCtx tycon)+ = text "the VECTORISE pragma for type constructor" <+> quotes (ppr tycon)
simplCore/CSE.hs view
@@ -10,20 +10,24 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSubst import Var ( Var )-import VarEnv ( elemInScopeSet )+import VarEnv ( elemInScopeSet, mkInScopeSet ) import Id ( Id, idType, idInlineActivation, isDeadBinder , zapIdOccInfo, zapIdUsageInfo, idInlinePragma , isJoinId ) import CoreUtils ( mkAltExpr, eqExpr , exprIsLiteralString , stripTicksE, stripTicksT, mkTicks )+import CoreFVs ( exprFreeVars ) import Type ( tyConAppArgs ) import CoreSyn import Outputable import BasicTypes ( TopLevelFlag(..), isTopLevel- , isAlwaysActive, isAnyInlinePragma )+ , isAlwaysActive, isAnyInlinePragma,+ inlinePragmaSpec, noUserInlineSpec ) import TrieMap import Util ( filterOut ) import Data.List ( mapAccumL )@@ -154,7 +158,7 @@ This is the main reason that addBinding is called with a trivial rhs. * Non-trivial scrutinee- case (f x) of y { pat -> ...let y = f x in ... }+ case (f x) of y { pat -> ...let z = f x in ... } By using addBinding we'll add (f x :-> y) to the cs_map, and thereby CSE the inner (f x) to y.@@ -204,8 +208,12 @@ might replace <rhs> by 'bar', and then later be unable to see that it really was <rhs>. +An except to the rule is when the INLINE pragma is not from the user, e.g. from+WorkWrap (see Note [Wrapper activation]). We can tell because noUserInlineSpec+is then true.+ Note that we do not (currently) do CSE on the unfolding stored inside-an Id, even if is a 'stable' unfolding. That means that when an+an Id, even if it is a 'stable' unfolding. That means that when an unfolding happens, it is always faithful to what the stable unfolding originally was. @@ -334,6 +342,11 @@ do_one env (pr, b1) = cse_bind toplevel env pr b1 +-- | Given a binding of @in_id@ to @in_rhs@, and a fresh name to refer+-- to @in_id@ (@out_id@, created from addBinder or addRecBinders),+-- first try to CSE @in_rhs@, and then add the resulting (possibly CSE'd)+-- binding to the 'CSEnv', so that we attempt to CSE any expressions+-- which are equal to @out_rhs@. cse_bind :: TopLevelFlag -> CSEnv -> (InId, InExpr) -> OutId -> (CSEnv, (OutId, OutExpr)) cse_bind toplevel env (in_id, in_rhs) out_id | isTopLevel toplevel, exprIsLiteralString in_rhs@@ -380,7 +393,8 @@ _ -> False noCSE :: InId -> Bool-noCSE id = not (isAlwaysActive (idInlineActivation id))+noCSE id = not (isAlwaysActive (idInlineActivation id)) &&+ not (noUserInlineSpec (inlinePragmaSpec (idInlinePragma id))) -- See Note [CSE for INLINE and NOINLINE] || isAnyInlinePragma (idInlinePragma id) -- See Note [CSE for stable unfoldings]@@ -439,8 +453,13 @@ -- top of the replaced sub-expression. This is probably not too -- useful in practice, but upholds our semantics. +-- | Runs CSE on a single expression.+--+-- This entry point is not used in the compiler itself, but is provided+-- as a convenient entry point for users of the GHC API. cseOneExpr :: InExpr -> OutExpr-cseOneExpr = cseExpr emptyCSEnv+cseOneExpr e = cseExpr env e+ where env = emptyCSEnv {cs_subst = mkEmptySubst (mkInScopeSet (exprFreeVars e)) } cseExpr :: CSEnv -> InExpr -> OutExpr cseExpr env (Type t) = Type (substTy (csEnvSubst env) t)@@ -449,7 +468,7 @@ cseExpr env (Var v) = lookupSubst env v cseExpr env (App f a) = App (cseExpr env f) (tryForCSE env a) cseExpr env (Tick t e) = Tick t (cseExpr env e)-cseExpr env (Cast e co) = Cast (cseExpr env e) (substCo (csEnvSubst env) co)+cseExpr env (Cast e co) = Cast (tryForCSE env e) (substCo (csEnvSubst env) co) cseExpr env (Lam b e) = let (env', b') = addBinder env b in Lam b' (cseExpr env' e) cseExpr env (Let bind e) = let (env', bind') = cseBind NotTopLevel env bind@@ -478,9 +497,11 @@ arg_tys :: [OutType] arg_tys = tyConAppArgs (idType bndr3) + -- Given case x of { K y z -> ...K y z... }+ -- CSE K y z into x... cse_alt (DataAlt con, args, rhs) | not (null args)- -- Don't try CSE if there are no args; it just increases the number+ -- ... but don't try CSE if there are no args; it just increases the number -- of live vars. E.g. -- case x of { True -> ....True.... } -- Don't replace True by x!@@ -512,7 +533,7 @@ {- Note [Combine case alternatives] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ combineAlts is just a more heavyweight version of the use of-combineIdentialAlts in SimplUtils.prepareAlts. The basic idea is+combineIdenticalAlts in SimplUtils.prepareAlts. The basic idea is to transform DEFAULT -> e1@@ -585,6 +606,9 @@ extendCSSubst :: CSEnv -> Id -> CoreExpr -> CSEnv extendCSSubst cse x rhs = cse { cs_subst = extendSubst (cs_subst cse) x rhs } +-- | Add clones to the substitution to deal with shadowing. See+-- Note [Shadowing] for more details. You should call this whenever+-- you go under a binder. addBinder :: CSEnv -> Var -> (CSEnv, Var) addBinder cse v = (cse { cs_subst = sub' }, v') where
simplCore/CallArity.hs view
@@ -7,6 +7,8 @@ , callArityRHS -- for testing ) where +import GhcPrelude+ import VarSet import VarEnv import DynFlags ( DynFlags )@@ -16,9 +18,9 @@ import Id import CoreArity ( typeArity ) import CoreUtils ( exprIsCheap, exprIsTrivial )---import Outputable import UnVarGraph import Demand+import Util import Control.Arrow ( first, second ) @@ -26,7 +28,7 @@ {- %************************************************************************ %* *- Call Arity Analyis+ Call Arity Analysis %* * %************************************************************************ @@ -76,7 +78,7 @@ What we want to know from an expression --------------------------------------- -In order to obtain that information for variables, we analyize expression and+In order to obtain that information for variables, we analyze expression and obtain bits of information: I. The arity analysis:@@ -95,7 +97,7 @@ The two analysis are not completely independent, as a higher arity can improve the information about what variables are being called once or multiple times. -Note [Analysis I: The arity analyis]+Note [Analysis I: The arity analysis] ------------------------------------ The arity analysis is quite straight forward: The information about an@@ -104,7 +106,7 @@ where absent variables are bound to Nothing and otherwise to a lower bound to their arity. -When we analyize an expression, we analyize it with a given context arity.+When we analyze an expression, we analyze it with a given context arity. Lambdas decrease and applications increase the incoming arity. Analysizing a variable will put that arity in the environment. In lets or cases all the results from the various subexpressions are lubed, which takes the point-wise@@ -350,7 +352,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We never eta-expand a thunk in a recursive group, on the grounds that if it is-part of a recursive group, then it will be called multipe times.+part of a recursive group, then it will be called multiple times. This is not necessarily true, e.g. it would be safe to eta-expand t2 (but not t1) in the following code:@@ -406,6 +408,26 @@ pattern-matching on a variable, and the benefits of eta-expansion likely oughtweigh the cost of doing that repeatedly. Therefore, this implementation of Call Arity considers everything that is not cheap (`exprIsCheap`) as a thunk.++Note [Call Arity and Join Points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++The Call Arity analysis does not care about join points, and treats them just+like normal functions. This is ok.++The analysis *could* make use of the fact that join points are always evaluated+in the same context as the join-binding they are defined in and are always+one-shot, and handle join points separately, as suggested in+https://ghc.haskell.org/trac/ghc/ticket/13479#comment:10.+This *might* be more efficient (for example, join points would not have to be+considered interesting variables), but it would also add redundant code. So for+now we do not do that.++The simplifier never eta-expands join points (it instead pushes extra arguments from+an eta-expanded context into the join point’s RHS), so the call arity+annotation on join points is not actually used. As it would be equally valid+(though less efficient) to eta-expand join points, this is the simplifier's+choice, and hence Call Arity sets the call arity for join points as well. -} -- Main entry point@@ -628,7 +650,9 @@ | safe_arity == 0 = ae_rhs -- If it is not a function, its body is evaluated only once | otherwise = calledMultipleTimes ae_rhs - in (True, (i `setIdCallArity` trimmed_arity, Just (called_once, new_arity, ae_rhs'), rhs'))+ i' = i `setIdCallArity` trimmed_arity++ in (True, (i', Just (called_once, new_arity, ae_rhs'), rhs')) where -- See Note [Taking boring variables into account] (new_arity, called_once) | i `elemVarSet` boring_vars = (0, False)@@ -650,11 +674,11 @@ cross_calls -- See Note [Taking boring variables into account]- | any_boring = completeGraph (domRes ae_combined)+ | any_boring = completeGraph (domRes ae_combined) -- Also, calculating cross_calls is expensive. Simply be conservative -- if the mutually recursive group becomes too large.- | length ae_rhss > 25 = completeGraph (domRes ae_combined)- | otherwise = unionUnVarGraphs $ map cross_call ae_rhss+ | lengthExceeds ae_rhss 25 = completeGraph (domRes ae_combined)+ | otherwise = unionUnVarGraphs $ map cross_call ae_rhss cross_call (v, ae_rhs) = completeBipartiteGraph called_by_v called_with_v where is_thunk = idCallArity v == 0@@ -687,7 +711,7 @@ --------------------------------------- -- Result type for the two analyses.--- See Note [Analysis I: The arity analyis]+-- See Note [Analysis I: The arity analysis] -- and Note [Analysis II: The Co-Called analysis] type CallArityRes = (UnVarGraph, VarEnv Arity)
simplCore/CoreMonad.hs view
@@ -9,7 +9,7 @@ module CoreMonad ( -- * Configuration of the core-to-core passes CoreToDo(..), runWhen, runMaybe,- SimplifierMode(..),+ SimplMode(..), FloatOutSwitches(..), pprPassDetails, @@ -53,6 +53,8 @@ thNameToGhcName ) where +import GhcPrelude hiding ( read )+ import Name( Name ) import TcRnMonad ( initTcForLookup ) import CoreSyn@@ -70,13 +72,11 @@ import FastString import qualified ErrUtils as Err import ErrUtils( Severity(..) )-import Maybes import UniqSupply import UniqFM ( UniqFM, mapUFM, filterUFM ) import MonadUtils import NameCache import SrcLoc-import ListSetOps ( runs ) import Data.List import Data.Ord import Data.Dynamic@@ -88,8 +88,6 @@ import Control.Monad import Control.Applicative ( Alternative(..) ) -import Prelude hiding ( read )- import {-# SOURCE #-} TcSplice ( lookupThName_maybe ) import qualified Language.Haskell.TH as TH @@ -108,7 +106,7 @@ = CoreDoSimplify -- The core-to-core simplifier. Int -- Max iterations- SimplifierMode+ SimplMode | CoreDoPluginPass String PluginPass | CoreDoFloatInwards | CoreDoFloatOutwards FloatOutSwitches@@ -116,6 +114,7 @@ | CoreDoPrintCore | CoreDoStaticArgs | CoreDoCallArity+ | CoreDoExitify | CoreDoStrictness | CoreDoWorkerWrapper | CoreDoSpecialising@@ -143,6 +142,7 @@ ppr CoreLiberateCase = text "Liberate case" ppr CoreDoStaticArgs = text "Static argument" ppr CoreDoCallArity = text "Called arity analysis"+ ppr CoreDoExitify = text "Exitification transformation" ppr CoreDoStrictness = text "Demand analysis" ppr CoreDoWorkerWrapper = text "Worker Wrapper binds" ppr CoreDoSpecialising = text "Specialise"@@ -164,17 +164,19 @@ , ppr md ] pprPassDetails _ = Outputable.empty -data SimplifierMode -- See comments in SimplMonad+data SimplMode -- See comments in SimplMonad = SimplMode { sm_names :: [String] -- Name(s) of the phase , sm_phase :: CompilerPhase+ , sm_dflags :: DynFlags -- Just for convenient non-monadic+ -- access; we don't override these , sm_rules :: Bool -- Whether RULES are enabled , sm_inline :: Bool -- Whether inlining is enabled , sm_case_case :: Bool -- Whether case-of-case is enabled , sm_eta_expand :: Bool -- Whether eta-expansion is enabled } -instance Outputable SimplifierMode where+instance Outputable SimplMode where ppr (SimplMode { sm_phase = p, sm_names = ss , sm_rules = r, sm_inline = i , sm_eta_expand = eta, sm_case_case = cc })@@ -252,7 +254,7 @@ -} getVerboseSimplStats :: (Bool -> SDoc) -> SDoc-getVerboseSimplStats = sdocWithPprDebug -- For now, anyway+getVerboseSimplStats = getPprDebug -- For now, anyway zeroSimplCount :: DynFlags -> SimplCount isZeroSimplCount :: SimplCount -> Bool@@ -348,7 +350,7 @@ where groups :: [[(Tick,Int)]] -- Each group shares a comon tag -- toList returns common tags adjacent- groups = runs same_tag (Map.toList counts)+ groups = groupBy same_tag (Map.toList counts) same_tag (tick1,_) (tick2,_) = tickToTag tick1 == tickToTag tick2 pprTickGroup :: [(Tick, Int)] -> SDoc
+ simplCore/Exitify.hs view
@@ -0,0 +1,442 @@+module Exitify ( exitifyProgram ) where++{-+Note [Exitification]+~~~~~~~~~~~~~~~~~~~~++This module implements Exitification. The goal is to pull as much code out of+recursive functions as possible, as the simplifier is better at inlining into+call-sites that are not in recursive functions.++Example:++ let t = foo bar+ joinrec go 0 x y = t (x*x)+ go (n-1) x y = jump go (n-1) (x+y)+ in …++We’d like to inline `t`, but that does not happen: Because t is a thunk and is+used in a recursive function, doing so might lose sharing in general. In+this case, however, `t` is on the _exit path_ of `go`, so called at most once.+How do we make this clearly visible to the simplifier?++A code path (i.e., an expression in a tail-recursive position) in a recursive+function is an exit path if it does not contain a recursive call. We can bind+this expression outside the recursive function, as a join-point.++Example result:++ let t = foo bar+ join exit x = t (x*x)+ joinrec go 0 x y = jump exit x+ go (n-1) x y = jump go (n-1) (x+y)+ in …++Now `t` is no longer in a recursive function, and good things happen!+-}++import GhcPrelude+import Var+import Id+import IdInfo+import CoreSyn+import CoreUtils+import State+import Unique+import VarSet+import VarEnv+import CoreFVs+import FastString+import Type++import Data.Bifunctor+import Control.Monad++-- | Traverses the AST, simply to find all joinrecs and call 'exitify' on them.+exitifyProgram :: CoreProgram -> CoreProgram+exitifyProgram binds = map goTopLvl binds+ where+ goTopLvl (NonRec v e) = NonRec v (go in_scope_toplvl e)+ goTopLvl (Rec pairs) = Rec (map (second (go in_scope_toplvl)) pairs)++ in_scope_toplvl = emptyInScopeSet `extendInScopeSetList` bindersOfBinds binds++ go :: InScopeSet -> CoreExpr -> CoreExpr+ go _ e@(Var{}) = e+ go _ e@(Lit {}) = e+ go _ e@(Type {}) = e+ go _ e@(Coercion {}) = e++ go in_scope (Lam v e') = Lam v (go in_scope' e')+ where in_scope' = in_scope `extendInScopeSet` v+ go in_scope (App e1 e2) = App (go in_scope e1) (go in_scope e2)+ go in_scope (Case scrut bndr ty alts)+ = Case (go in_scope scrut) bndr ty (map (goAlt in_scope') alts)+ where in_scope' = in_scope `extendInScopeSet` bndr+ go in_scope (Cast e' c) = Cast (go in_scope e') c+ go in_scope (Tick t e') = Tick t (go in_scope e')+ go in_scope (Let bind body) = goBind in_scope bind (go in_scope' body)+ where in_scope' = in_scope `extendInScopeSetList` bindersOf bind++ goAlt :: InScopeSet -> CoreAlt -> CoreAlt+ goAlt in_scope (dc, pats, rhs) = (dc, pats, go in_scope' rhs)+ where in_scope' = in_scope `extendInScopeSetList` pats++ goBind :: InScopeSet -> CoreBind -> (CoreExpr -> CoreExpr)+ goBind in_scope (NonRec v rhs) = Let (NonRec v (go in_scope rhs))+ goBind in_scope (Rec pairs)+ | is_join_rec = exitify in_scope' pairs'+ | otherwise = Let (Rec pairs')+ where pairs' = map (second (go in_scope')) pairs+ is_join_rec = any (isJoinId . fst) pairs+ in_scope' = in_scope `extendInScopeSetList` bindersOf (Rec pairs)++-- | Given a recursive group of a joinrec, identifies “exit paths” and binds them as+-- join-points outside the joinrec.+exitify :: InScopeSet -> [(Var,CoreExpr)] -> (CoreExpr -> CoreExpr)+exitify in_scope pairs =+ \body ->mkExitLets exits (mkLetRec pairs' body)+ where+ mkExitLets ((exitId, exitRhs):exits') = mkLetNonRec exitId exitRhs . mkExitLets exits'+ mkExitLets [] = id++ -- We need the set of free variables of many subexpressions here, so+ -- annotate the AST with them+ -- see Note [Calculating free variables]+ ann_pairs = map (second freeVars) pairs++ -- Which are the recursive calls?+ recursive_calls = mkVarSet $ map fst pairs++ (pairs',exits) = (`runState` []) $ do+ forM ann_pairs $ \(x,rhs) -> do+ -- go past the lambdas of the join point+ let (args, body) = collectNAnnBndrs (idJoinArity x) rhs+ body' <- go args body+ let rhs' = mkLams args body'+ return (x, rhs')++ -- main working function. Goes through the RHS (tail-call positions only),+ -- checks if there are no more recursive calls, if so, abstracts over+ -- variables bound on the way and lifts it out as a join point.+ --+ -- It uses a state monad to keep track of floated binds+ go :: [Var] -- ^ variables to abstract over+ -> CoreExprWithFVs -- ^ current expression in tail position+ -> State [(Id, CoreExpr)] CoreExpr++ go captured ann_e+ -- Do not touch an expression that is already a join jump where all arguments+ -- are captured variables. See Note [Idempotency]+ -- But _do_ float join jumps with interesting arguments.+ -- See Note [Jumps can be interesting]+ | (Var f, args) <- collectArgs e+ , isJoinId f+ , all isCapturedVarArg args+ = return e++ -- Do not touch a boring expression (see Note [Interesting expression])+ | is_exit, not is_interesting = return e++ -- Cannot float out if local join points are used, as+ -- we cannot abstract over them+ | is_exit, captures_join_points = return e++ -- We have something to float out!+ | is_exit = do+ -- Assemble the RHS of the exit join point+ let rhs = mkLams args e+ ty = exprType rhs+ let avoid = in_scope `extendInScopeSetList` captured+ -- Remember this binding under a suitable name+ v <- addExit avoid ty (length args) rhs+ -- And jump to it from here+ return $ mkVarApps (Var v) args+ where+ -- An exit expression has no recursive calls+ is_exit = disjointVarSet fvs recursive_calls++ -- Used to detect exit expressoins that are already proper exit jumps+ isCapturedVarArg (Var v) = v `elem` captured+ isCapturedVarArg _ = False++ -- An interesting exit expression has free, non-imported+ -- variables from outside the recursive group+ -- See Note [Interesting expression]+ is_interesting = anyVarSet isLocalId (fvs `minusVarSet` mkVarSet captured)++ -- The possible arguments of this exit join point+ args = filter (`elemVarSet` fvs) captured++ -- We cannot abstract over join points+ captures_join_points = any isJoinId args++ e = deAnnotate ann_e+ fvs = dVarSetToVarSet (freeVarsOf ann_e)+++ -- Case right hand sides are in tail-call position+ go captured (_, AnnCase scrut bndr ty alts) = do+ alts' <- forM alts $ \(dc, pats, rhs) -> do+ rhs' <- go (captured ++ [bndr] ++ pats) rhs+ return (dc, pats, rhs')+ return $ Case (deAnnotate scrut) bndr ty alts'++ go captured (_, AnnLet ann_bind body)+ -- join point, RHS and body are in tail-call position+ | AnnNonRec j rhs <- ann_bind+ , Just join_arity <- isJoinId_maybe j+ = do let (params, join_body) = collectNAnnBndrs join_arity rhs+ join_body' <- go (captured ++ params) join_body+ let rhs' = mkLams params join_body'+ body' <- go (captured ++ [j]) body+ return $ Let (NonRec j rhs') body'++ -- rec join point, RHSs and body are in tail-call position+ | AnnRec pairs <- ann_bind+ , isJoinId (fst (head pairs))+ = do let js = map fst pairs+ pairs' <- forM pairs $ \(j,rhs) -> do+ let join_arity = idJoinArity j+ (params, join_body) = collectNAnnBndrs join_arity rhs+ join_body' <- go (captured ++ js ++ params) join_body+ let rhs' = mkLams params join_body'+ return (j, rhs')+ body' <- go (captured ++ js) body+ return $ Let (Rec pairs') body'++ -- normal Let, only the body is in tail-call position+ | otherwise+ = do body' <- go (captured ++ bindersOf bind ) body+ return $ Let bind body'+ where bind = deAnnBind ann_bind++ go _ ann_e = return (deAnnotate ann_e)+++-- Picks a new unique, which is disjoint from+-- * the free variables of the whole joinrec+-- * any bound variables (captured)+-- * any exit join points created so far.+mkExitJoinId :: InScopeSet -> Type -> JoinArity -> ExitifyM JoinId+mkExitJoinId in_scope ty join_arity = do+ fs <- get+ let avoid = in_scope `extendInScopeSetList` (map fst fs)+ `extendInScopeSet` exit_id_tmpl -- just cosmetics+ return (uniqAway avoid exit_id_tmpl)+ where+ exit_id_tmpl = mkSysLocal (fsLit "exit") initExitJoinUnique ty+ `asJoinId` join_arity+ `setIdOccInfo` exit_occ_info++ -- See Note [Do not inline exit join points]+ exit_occ_info =+ OneOcc { occ_in_lam = True+ , occ_one_br = True+ , occ_int_cxt = False+ , occ_tail = AlwaysTailCalled join_arity }++addExit :: InScopeSet -> Type -> JoinArity -> CoreExpr -> ExitifyM JoinId+addExit in_scope ty join_arity rhs = do+ -- Pick a suitable name+ v <- mkExitJoinId in_scope ty join_arity+ fs <- get+ put ((v,rhs):fs)+ return v+++type ExitifyM = State [(JoinId, CoreExpr)]++{-+Note [Interesting expression]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++We do not want this to happen:++ joinrec go 0 x y = x+ go (n-1) x y = jump go (n-1) (x+y)+ in …+==>+ join exit x = x+ joinrec go 0 x y = jump exit x+ go (n-1) x y = jump go (n-1) (x+y)+ in …++because the floated exit path (`x`) is simply a parameter of `go`; there are+not useful interactions exposed this way.++Neither do we want this to happen++ joinrec go 0 x y = x+x+ go (n-1) x y = jump go (n-1) (x+y)+ in …+==>+ join exit x = x+x+ joinrec go 0 x y = jump exit x+ go (n-1) x y = jump go (n-1) (x+y)+ in …++where the floated expression `x+x` is a bit more complicated, but still not+intersting.++Expressions are interesting when they move an occurrence of a variable outside+the recursive `go` that can benefit from being obviously called once, for example:+ * a local thunk that can then be inlined (see example in note [Exitification])+ * the parameter of a function, where the demand analyzer then can then+ see that it is called at most once, and hence improve the function’s+ strictness signature++So we only hoist an exit expression out if it mentiones at least one free,+non-imported variable.++Note [Jumps can be interesting]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++A jump to a join point can be interesting, if its arguments contain free+non-exported variables (z in the following example):++ joinrec go 0 x y = jump j (x+z)+ go (n-1) x y = jump go (n-1) (x+y)+ in …+==>+ join exit x y = jump j (x+z)+ joinrec go 0 x y = jump exit x+ go (n-1) x y = jump go (n-1) (x+y)+++The join point itself can be interesting, even if none if+its arguments are (assume `g` to be an imported function that, on its own, does+not make this interesting):++ join j y = map f y+ joinrec go 0 x y = jump j (map g x)+ go (n-1) x y = jump go (n-1) (x+y)+ in …++Here, `j` would not be inlined because we do not inline something that looks+like an exit join point (see Note [Do not inline exit join points]).++But after exitification we have++ join j y = map f y+ join exit x = jump j (map g x)+ joinrec go 0 x y = jump j (map g x)+ go (n-1) x y = jump go (n-1) (x+y)+ in …++and now we can inline `j` and this will allow `map/map` to fire.+++Note [Idempotency]+~~~~~~~~~~~~~~~~~~++We do not want this to happen, where we replace the floated expression with+essentially the same expression:++ join exit x = t (x*x)+ joinrec go 0 x y = jump exit x+ go (n-1) x y = jump go (n-1) (x+y)+ in …+==>+ join exit x = t (x*x)+ join exit' x = jump exit x+ joinrec go 0 x y = jump exit' x+ go (n-1) x y = jump go (n-1) (x+y)+ in …++So when the RHS is a join jump, and all of its arguments are captured variables,+then we leave it in place.++Note that `jump exit x` in this example looks interesting, as `exit` is a free+variable. Therefore, idempotency does not simply follow from floating only+interesting expressions.++Note [Calculating free variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++We have two options where to annotate the tree with free variables:++ A) The whole tree.+ B) Each individual joinrec as we come across it.++Downside of A: We pay the price on the whole module, even outside any joinrecs.+Downside of B: We pay the price per joinrec, possibly multiple times when+joinrecs are nested.++Further downside of A: If the exitify function returns annotated expressions,+it would have to ensure that the annotations are correct.+++Note [Do not inline exit join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++When we have++ let t = foo bar+ join exit x = t (x*x)+ joinrec go 0 x y = jump exit x+ go (n-1) x y = jump go (n-1) (x+y)+ in …++we do not want the simplifier to simply inline `exit` back in (which it happily+would).++To prevent this, we need to recognize exit join points, and then disable+inlining.++Exit join points, recognizeable using `isExitJoinId` are join points with an+occurence in a recursive group, and can be recognized using `isExitJoinId`.+This function detects joinpoints with `occ_in_lam (idOccinfo id) == True`,+because the lambdas of a non-recursive join point are not considered for+`occ_in_lam`. For example, in the following code, `j1` is /not/ marked+occ_in_lam, because `j2` is called only once.++ join j1 x = x+1+ join j2 y = join j1 (y+2)++We create exit join point ids with such an `OccInfo`, see `exit_occ_info`.++To prevent inlining, we check for that in `preInlineUnconditionally` directly.+For `postInlineUnconditionally` and unfolding-based inlining, the function+`simplLetUnfolding` simply gives exit join points no unfolding, which prevents+this kind of inlining.++Note [Placement of the exitification pass]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++I (Joachim) experimented with multiple positions for the Exitification pass in+the Core2Core pipeline:++ A) Before the `simpl_phases`+ B) Between the `simpl_phases` and the "main" simplifier pass+ C) After demand_analyser+ D) Before the final simplification phase++Here is the table (this is without inlining join exit points in the final+simplifier run):++ Program | Allocs | Instrs+ | ABCD.log A.log B.log C.log D.log | ABCD.log A.log B.log C.log D.log+----------------|---------------------------------------------------|-------------------------------------------------+ fannkuch-redux | -99.9% +0.0% -99.9% -99.9% -99.9% | -3.9% +0.5% -3.0% -3.9% -3.9%+ fasta | -0.0% +0.0% +0.0% -0.0% -0.0% | -8.5% +0.0% +0.0% -0.0% -8.5%+ fem | 0.0% 0.0% 0.0% 0.0% +0.0% | -2.2% -0.1% -0.1% -2.1% -2.1%+ fish | 0.0% 0.0% 0.0% 0.0% +0.0% | -3.1% +0.0% -1.1% -1.1% -0.0%+ k-nucleotide | -91.3% -91.0% -91.0% -91.3% -91.3% | -6.3% +11.4% +11.4% -6.3% -6.2%+ scs | -0.0% -0.0% -0.0% -0.0% -0.0% | -3.4% -3.0% -3.1% -3.3% -3.3%+ simple | -6.0% 0.0% -6.0% -6.0% +0.0% | -3.4% +0.0% -5.2% -3.4% -0.1%+ spectral-norm | -0.0% 0.0% 0.0% -0.0% +0.0% | -2.7% +0.0% -2.7% -5.4% -5.4%+----------------|---------------------------------------------------|-------------------------------------------------+ Min | -95.0% -91.0% -95.0% -95.0% -95.0% | -8.5% -3.0% -5.2% -6.3% -8.5%+ Max | +0.2% +0.2% +0.2% +0.2% +1.5% | +0.4% +11.4% +11.4% +0.4% +1.5%+ Geometric Mean | -4.7% -2.1% -4.7% -4.7% -4.6% | -0.4% +0.1% -0.1% -0.3% -0.2%++Position A is disqualified, as it does not get rid of the allocations in+fannkuch-redux.+Position A and B are disqualified because it increases instructions in k-nucleotide.+Positions C and D have their advantages: C decreases allocations in simpl, but D instructions in fasta.++Assuming we have a budget of _one_ run of Exitification, then C wins (but we+could get more from running it multiple times, as seen in fish).++-}
simplCore/FloatIn.hs view
@@ -13,26 +13,28 @@ -} {-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -fprof-auto #-} module FloatIn ( floatInwards ) where #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import MkCore import HscTypes ( ModGuts(..) )-import CoreUtils ( exprIsDupable, exprIsExpandable,- exprOkForSideEffects, mkTicks )+import CoreUtils import CoreFVs import CoreMonad ( CoreM ) import Id ( isOneShotBndr, idType, isJoinId, isJoinId_maybe ) import Var-import Type ( isUnliftedType )+import Type import VarSet import Util import DynFlags import Outputable-import Data.List ( mapAccumL )+-- import Data.List ( mapAccumL ) import BasicTypes ( RecFlag(..), isRec ) {-@@ -151,7 +153,6 @@ [drop_here, e_drop, co_drop] = sepBindsByDropPoint dflags False [freeVarsOf expr, freeVarsOfAnn co_ann]- (freeVarsOfType expr `unionDVarSet` freeVarsOfTypeAnn co_ann) to_drop {-@@ -161,33 +162,45 @@ -} fiExpr dflags to_drop ann_expr@(_,AnnApp {})- = mkTicks ticks $ wrapFloats drop_here $ wrapFloats extra_drop $+ = wrapFloats drop_here $ wrapFloats extra_drop $+ mkTicks ticks $ mkApps (fiExpr dflags fun_drop ann_fun) (zipWith (fiExpr dflags) arg_drops ann_args) where (ann_fun, ann_args, ticks) = collectAnnArgsTicks tickishFloatable ann_expr- (extra_fvs0, fun_fvs)- | (_, AnnVar _) <- ann_fun = (freeVarsOf ann_fun, emptyDVarSet)+ fun_ty = exprType (deAnnotate ann_fun)+ fun_fvs = freeVarsOf ann_fun+ arg_fvs = map freeVarsOf ann_args++ (drop_here : extra_drop : fun_drop : arg_drops)+ = sepBindsByDropPoint dflags False+ (extra_fvs : fun_fvs : arg_fvs)+ to_drop+ -- Shortcut behaviour: if to_drop is empty,+ -- sepBindsByDropPoint returns a suitable bunch of empty+ -- lists without evaluating extra_fvs, and hence without+ -- peering into each argument++ (_, extra_fvs) = foldl add_arg (fun_ty, extra_fvs0) ann_args+ extra_fvs0 = case ann_fun of+ (_, AnnVar _) -> fun_fvs+ _ -> emptyDVarSet -- Don't float the binding for f into f x y z; see Note [Join points] -- for why we *can't* do it when f is a join point. (If f isn't a -- join point, floating it in isn't especially harmful but it's -- useless since the simplifier will immediately float it back out.)- | otherwise = (emptyDVarSet, freeVarsOf ann_fun)- (extra_fvs, arg_fvs) = mapAccumL mk_arg_fvs extra_fvs0 ann_args - mk_arg_fvs :: FreeVarSet -> CoreExprWithFVs -> (FreeVarSet, FreeVarSet)- mk_arg_fvs extra_fvs ann_arg- | noFloatIntoRhs False NonRecursive ann_arg- = (extra_fvs `unionDVarSet` freeVarsOf ann_arg, emptyDVarSet)- | otherwise- = (extra_fvs, freeVarsOf ann_arg)+ add_arg :: (Type,FreeVarSet) -> CoreExprWithFVs -> (Type,FreeVarSet)+ add_arg (fun_ty, extra_fvs) (_, AnnType ty)+ = (piResultTy fun_ty ty, extra_fvs) - drop_here : extra_drop : fun_drop : arg_drops- = sepBindsByDropPoint dflags False- (extra_fvs : fun_fvs : arg_fvs)- (freeVarsOfType ann_fun `unionDVarSet`- mapUnionDVarSet freeVarsOfType ann_args)- to_drop+ add_arg (fun_ty, extra_fvs) (arg_fvs, arg)+ | noFloatIntoArg arg arg_ty+ = (res_ty, extra_fvs `unionDVarSet` arg_fvs)+ | otherwise+ = (res_ty, extra_fvs)+ where+ (arg_ty, res_ty) = splitFunTy fun_ty {- Note [Do not destroy the let/app invariant]@@ -260,16 +273,37 @@ Urk! if all are tyvars, and we don't float in, we may miss an opportunity to float inside a nested case branch+++Note [Floating coercions]+~~~~~~~~~~~~~~~~~~~~~~~~~+We could, in principle, have a coercion binding like+ case f x of co { DEFAULT -> e1 e2 }+It's not common to have a function that returns a coercion, but nothing+in Core prohibits it. If so, 'co' might be mentioned in e1 or e2+/only in a type/. E.g. suppose e1 was+ let (x :: Int |> co) = blah in blah2+++But, with coercions appearing in types, there is a complication: we+might be floating in a "strict let" -- that is, a case. Case expressions+mention their return type. We absolutely can't float a coercion binding+inward to the point that the type of the expression it's about to wrap+mentions the coercion. So we include the union of the sets of free variables+of the types of all the drop points involved. If any of the floaters+bind a coercion variable mentioned in any of the types, that binder must+be dropped right away.+ -} fiExpr dflags to_drop lam@(_, AnnLam _ _)- | okToFloatInside bndrs -- Float in+ | noFloatIntoLam bndrs -- Dump it all here -- NB: Must line up with noFloatIntoRhs (AnnLam...); see Trac #7088- = mkLams bndrs (fiExpr dflags to_drop body)-- | otherwise -- Dump it all here = wrapFloats to_drop (mkLams bndrs (fiExpr dflags [] body)) + | otherwise -- Float inside+ = mkLams bndrs (fiExpr dflags to_drop body)+ where (bndrs, body) = collectAnnBndrs lam @@ -342,42 +376,79 @@ = fiExpr dflags (after ++ new_float : before) body -- to_drop is in reverse dependency order where- (before, new_float, after) = fiBind dflags to_drop bind body_fvs body_ty_fvs+ (before, new_float, after) = fiBind dflags to_drop bind body_fvs body_fvs = freeVarsOf body- body_ty_fvs = freeVarsOfType body -{--For @Case@, the possible ``drop points'' for the \tr{to_drop}-bindings are: (a)~inside the scrutinee, (b)~inside one of the-alternatives/default [default FVs always {\em first}!].+{- Note [Floating primops]+~~~~~~~~~~~~~~~~~~~~~~~~~~+We try to float-in a case expression over an unlifted type. The+motivating example was Trac #5658: in particular, this change allows+array indexing operations, which have a single DEFAULT alternative+without any binders, to be floated inward. -Floating case expressions inward was added to fix Trac #5658: strict bindings-not floated in. In particular, this change allows array indexing operations,-which have a single DEFAULT alternative without any binders, to be floated-inward. SIMD primops for unpacking SIMD vectors into an unboxed tuple of unboxed+SIMD primops for unpacking SIMD vectors into an unboxed tuple of unboxed scalars also need to be floated inward, but unpacks have a single non-DEFAULT alternative that binds the elements of the tuple. We now therefore also support floating in cases with a single alternative that may bind values.++But there are wrinkles++* Which unlifted cases do we float? See PrimOp.hs+ Note [PrimOp can_fail and has_side_effects] which explains:+ - We can float-in can_fail primops, but we can't float them out.+ - But we can float a has_side_effects primop, but NOT inside a lambda,+ so for now we don't float them at all.+ Hence exprOkForSideEffects++* Because we can float can-fail primops (array indexing, division) inwards+ but not outwards, we must be careful not to transform+ case a /# b of r -> f (F# r)+ ===>+ f (case a /# b of r -> F# r)+ because that creates a new thunk that wasn't there before. And+ because it can't be floated out (can_fail), the thunk will stay+ there. Disaster! (This happened in nofib 'simple' and 'scs'.)++ Solution: only float cases into the branches of other cases, and+ not into the arguments of an application, or the RHS of a let. This+ is somewhat conservative, but it's simple. And it still hits the+ cases like Trac #5658. This is implemented in sepBindsByJoinPoint;+ if is_case is False we dump all floating cases right here.++* Trac #14511 is another example of why we want to restrict float-in+ of case-expressions. Consider+ case indexArray# a n of (# r #) -> writeArray# ma i (f r)+ Now, floating that indexing operation into the (f r) thunk will+ not create any new thunks, but it will keep the array 'a' alive+ for much longer than the programmer expected.++ So again, not floating a case into a let or argument seems like+ the Right Thing++For @Case@, the possible drop points for the 'to_drop'+bindings are:+ (a) inside the scrutinee+ (b) inside one of the alternatives/default (default FVs always /first/!).+ -} fiExpr dflags to_drop (_, AnnCase scrut case_bndr _ [(con,alt_bndrs,rhs)]) | isUnliftedType (idType case_bndr) , exprOkForSideEffects (deAnnotate scrut)- -- See PrimOp, Note [PrimOp can_fail and has_side_effects]+ -- See Note [Floating primops] = wrapFloats shared_binds $ fiExpr dflags (case_float : rhs_binds) rhs where case_float = FB (mkDVarSet (case_bndr : alt_bndrs)) scrut_fvs (FloatCase scrut' case_bndr con alt_bndrs)- scrut' = fiExpr dflags scrut_binds scrut+ scrut' = fiExpr dflags scrut_binds scrut+ rhs_fvs = freeVarsOf rhs `delDVarSetList` (case_bndr : alt_bndrs)+ scrut_fvs = freeVarsOf scrut+ [shared_binds, scrut_binds, rhs_binds] = sepBindsByDropPoint dflags False [scrut_fvs, rhs_fvs]- (freeVarsOfType scrut `unionDVarSet` rhs_ty_fvs) to_drop- rhs_fvs = freeVarsOf rhs `delDVarSetList` (case_bndr : alt_bndrs)- rhs_ty_fvs = freeVarsOfType rhs `delDVarSetList` (case_bndr : alt_bndrs)- scrut_fvs = freeVarsOf scrut fiExpr dflags to_drop (_, AnnCase scrut case_bndr ty alts) = wrapFloats drop_here1 $@@ -389,25 +460,20 @@ [drop_here1, scrut_drops, alts_drops] = sepBindsByDropPoint dflags False [scrut_fvs, all_alts_fvs]- (freeVarsOfType scrut `unionDVarSet` all_alts_ty_fvs) to_drop -- Float into the alts with the is_case flag set (drop_here2 : alts_drops_s)- = sepBindsByDropPoint dflags True alts_fvs all_alts_ty_fvs- alts_drops+ | [ _ ] <- alts = [] : [alts_drops]+ | otherwise = sepBindsByDropPoint dflags True alts_fvs alts_drops - scrut_fvs = freeVarsOf scrut- alts_fvs = map alt_fvs alts- all_alts_fvs = unionDVarSets alts_fvs- alts_ty_fvs = map alt_ty_fvs alts- all_alts_ty_fvs = unionDVarSets alts_ty_fvs+ scrut_fvs = freeVarsOf scrut+ alts_fvs = map alt_fvs alts+ all_alts_fvs = unionDVarSets alts_fvs alt_fvs (_con, args, rhs)- = foldl delDVarSet (freeVarsOf rhs) (case_bndr:args)- alt_ty_fvs (_con, args, rhs)- = foldl delDVarSet (freeVarsOfType rhs) (case_bndr:args)- -- Delete case_bndr and args from free vars of rhs- -- to get free vars of alt+ = foldl delDVarSet (freeVarsOf rhs) (case_bndr:args)+ -- Delete case_bndr and args from free vars of rhs+ -- to get free vars of alt fi_alt to_drop (con, args, rhs) = (con, args, fiExpr dflags to_drop rhs) @@ -417,12 +483,11 @@ -- as far "inwards" as possible -> CoreBindWithFVs -- Input binding -> DVarSet -- Free in scope of binding- -> DVarSet -- Free in type of body of binding -> ( FloatInBinds -- Land these before , FloatInBind -- The binding itself , FloatInBinds) -- Land these after -fiBind dflags to_drop (AnnNonRec id rhs) body_fvs body_ty_fvs+fiBind dflags to_drop (AnnNonRec id ann_rhs@(rhs_fvs, rhs)) body_fvs = ( extra_binds ++ shared_binds -- Land these before -- See Note [extra_fvs (1,2)] , FB (unitDVarSet id) rhs_fvs' -- The new binding itself@@ -431,11 +496,10 @@ where body_fvs2 = body_fvs `delDVarSet` id- rhs_fvs = freeVarsOf rhs rule_fvs = bndrRuleAndUnfoldingVarsDSet id -- See Note [extra_fvs (2): free variables of rules]- extra_fvs | noFloatIntoRhs (isJoinId id) NonRecursive rhs- = rule_fvs `unionDVarSet` freeVarsOf rhs+ extra_fvs | noFloatIntoRhs NonRecursive id rhs+ = rule_fvs `unionDVarSet` rhs_fvs | otherwise = rule_fvs -- See Note [extra_fvs (1): avoid floating into RHS]@@ -446,15 +510,14 @@ [shared_binds, extra_binds, rhs_binds, body_binds] = sepBindsByDropPoint dflags False [extra_fvs, rhs_fvs, body_fvs2]- (freeVarsOfType rhs `unionDVarSet` body_ty_fvs) to_drop -- Push rhs_binds into the right hand side of the binding- rhs' = fiRhs dflags rhs_binds id rhs+ rhs' = fiRhs dflags rhs_binds id ann_rhs rhs_fvs' = rhs_fvs `unionDVarSet` floatedBindsFVs rhs_binds `unionDVarSet` rule_fvs -- Don't forget the rule_fvs; the binding mentions them! -fiBind dflags to_drop (AnnRec bindings) body_fvs body_ty_fvs+fiBind dflags to_drop (AnnRec bindings) body_fvs = ( extra_binds ++ shared_binds , FB (mkDVarSet ids) rhs_fvs' (FloatLet (Rec (fi_bind rhss_binds bindings)))@@ -466,13 +529,12 @@ -- See Note [extra_fvs (1,2)] rule_fvs = mapUnionDVarSet bndrRuleAndUnfoldingVarsDSet ids extra_fvs = rule_fvs `unionDVarSet`- unionDVarSets [ freeVarsOf rhs | (bndr, rhs) <- bindings- , noFloatIntoRhs (isJoinId bndr) Recursive rhs ]+ unionDVarSets [ rhs_fvs | (bndr, (rhs_fvs, rhs)) <- bindings+ , noFloatIntoRhs Recursive bndr rhs ] (shared_binds:extra_binds:body_binds:rhss_binds) = sepBindsByDropPoint dflags False (extra_fvs:body_fvs:rhss_fvs)- (body_ty_fvs `unionDVarSet` mapUnionDVarSet freeVarsOfType rhss) to_drop rhs_fvs' = unionDVarSets rhss_fvs `unionDVarSet`@@ -498,45 +560,75 @@ = fiExpr dflags to_drop rhs -------------------okToFloatInside :: [Var] -> Bool-okToFloatInside bndrs = all ok bndrs+noFloatIntoLam :: [Var] -> Bool+noFloatIntoLam bndrs = any bad bndrs where- ok b = not (isId b) || isOneShotBndr b- -- Push the floats inside there are no non-one-shot value binders+ bad b = isId b && not (isOneShotBndr b)+ -- Don't float inside a non-one-shot lambda -noFloatIntoRhs :: Bool -> RecFlag -> CoreExprWithFVs -> Bool+noFloatIntoRhs :: RecFlag -> Id -> CoreExprWithFVs' -> Bool -- ^ True if it's a bad idea to float bindings into this RHS--- Preconditio: rhs :: rhs_ty-noFloatIntoRhs is_join is_rec rhs@(_, rhs')- | is_join- = isRec is_rec -- Joins are one-shot iff non-recursive- | otherwise- = isUnliftedType rhs_ty- -- See Note [Do not destroy the let/app invariant]- || noFloatIntoExpr rhs'+noFloatIntoRhs is_rec bndr rhs+ | isJoinId bndr+ = isRec is_rec -- Joins are one-shot iff non-recursive++ | otherwise+ = noFloatIntoArg rhs (idType bndr)++noFloatIntoArg :: CoreExprWithFVs' -> Type -> Bool+noFloatIntoArg expr expr_ty+ | isUnliftedType expr_ty+ = True -- See Note [Do not destroy the let/app invariant]++ | AnnLam bndr e <- expr+ , (bndrs, _) <- collectAnnBndrs e+ = noFloatIntoLam (bndr:bndrs) -- Wrinkle 1 (a)+ || all isTyVar (bndr:bndrs) -- Wrinkle 1 (b)+ -- See Note [noFloatInto considerations] wrinkle 2++ | otherwise -- Note [noFloatInto considerations] wrinkle 2+ = exprIsTrivial deann_expr || exprIsHNF deann_expr where- rhs_ty = exprTypeFV rhs+ deann_expr = deAnnotate' expr -noFloatIntoExpr :: CoreExprWithFVs' -> Bool-noFloatIntoExpr (AnnLam bndr e)- = not (okToFloatInside (bndr:bndrs))- -- NB: Must line up with fiExpr (AnnLam...); see Trac #7088- where- (bndrs, _) = collectAnnBndrs e- -- IMPORTANT: don't say 'True' for a RHS with a one-shot lambda at the top.- -- This makes a big difference for things like- -- f x# = let x = I# x#- -- in let j = \() -> ...x...- -- in if <condition> then normal-path else j ()- -- If x is used only in the error case join point, j, we must float the- -- boxing constructor into it, else we box it every time which is very bad- -- news indeed.+{- Note [noFloatInto considerations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When do we want to float bindings into+ - noFloatIntoRHs: the RHS of a let-binding+ - noFloatIntoArg: the argument of a function application -noFloatIntoExpr rhs = exprIsExpandable (deAnnotate' rhs)- -- We'd just float right back out again...- -- Should match the test in SimplEnv.doFloatFromRhs+Definitely don't float in if it has unlifted type; that+would destroy the let/app invariant. -{-+* Wrinkle 1: do not float in if+ (a) any non-one-shot value lambdas+ or (b) all type lambdas+ In both cases we'll float straight back out again+ NB: Must line up with fiExpr (AnnLam...); see Trac #7088++ (a) is important: we /must/ float into a one-shot lambda group+ (which includes join points). This makes a big difference+ for things like+ f x# = let x = I# x#+ in let j = \() -> ...x...+ in if <condition> then normal-path else j ()+ If x is used only in the error case join point, j, we must float the+ boxing constructor into it, else we box it every time which is very+ bad news indeed.++* Wrinkle 2: for RHSs, do not float into a HNF; we'll just float right+ back out again... not tragic, but a waste of time.++ For function arguments we will still end up with this+ in-then-out stuff; consider+ letrec x = e in f x+ Here x is not a HNF, so we'll produce+ f (letrec x = e in x)+ which is OK... it's not that common, and we'll end up+ floating out again, in CorePrep if not earlier.+ Still, we use exprIsTrivial to catch this case (sigh)++ ************************************************************************ * * \subsection{@sepBindsByDropPoint@}@@ -556,27 +648,21 @@ then it has to go in a you-must-drop-it-above-all-these-drop-points point. -But, with coercions appearing in types, there is a complication: we-might be floating in a "strict let" -- that is, a case. Case expressions-mention their return type. We absolutely can't float a coercion binding-inward to the point that the type of the expression it's about to wrap-mentions the coercion. So we include the union of the sets of free variables-of the types of all the drop points involved. If any of the floaters-bind a coercion variable mentioned in any of the types, that binder must-be dropped right away.- We have to maintain the order on these drop-point-related lists. -} +-- pprFIB :: FloatInBinds -> SDoc+-- pprFIB fibs = text "FIB:" <+> ppr [b | FB _ _ b <- fibs]+ sepBindsByDropPoint :: DynFlags- -> Bool -- True <=> is case expression- -> [FreeVarSet] -- One set of FVs per drop point- -> FreeVarSet -- Vars free in all the types of the drop points- -> FloatInBinds -- Candidate floaters+ -> Bool -- True <=> is case expression+ -> [FreeVarSet] -- One set of FVs per drop point+ -- Always at least two long!+ -> FloatInBinds -- Candidate floaters -> [FloatInBinds] -- FIRST one is bindings which must not be floated- -- inside any drop point; the rest correspond- -- one-to-one with the input list of FV sets+ -- inside any drop point; the rest correspond+ -- one-to-one with the input list of FV sets -- Every input floater is returned somewhere in the result; -- none are dropped, not even ones which don't seem to be@@ -586,12 +672,16 @@ type DropBox = (FreeVarSet, FloatInBinds) -sepBindsByDropPoint _ _is_case drop_pts _ty_fvs []- = [] : [[] | _ <- drop_pts] -- cut to the chase scene; it happens+sepBindsByDropPoint dflags is_case drop_pts floaters+ | null floaters -- Shortcut common case+ = [] : [[] | _ <- drop_pts] -sepBindsByDropPoint dflags is_case drop_pts ty_fvs floaters- = go floaters (map (\fvs -> (fvs, [])) (emptyDVarSet : drop_pts))+ | otherwise+ = ASSERT( drop_pts `lengthAtLeast` 2 )+ go floaters (map (\fvs -> (fvs, [])) (emptyDVarSet : drop_pts)) where+ n_alts = length drop_pts+ go :: FloatInBinds -> [DropBox] -> [FloatInBinds] -- The *first* one in the argument list is the drop_here set -- The FloatInBinds in the lists are in the reverse of@@ -606,32 +696,25 @@ (used_here : used_in_flags) = [ fvs `intersectsDVarSet` bndrs | (fvs, _) <- drop_boxes]- used_in_ty = ty_fvs `intersectsDVarSet` bndrs - drop_here = used_here || not can_push || used_in_ty-- -- For case expressions we duplicate the binding if it is- -- reasonably small, and if it is not used in all the RHSs- -- This is good for situations like- -- let x = I# y in- -- case e of- -- C -> error x- -- D -> error x- -- E -> ...not mentioning x...+ drop_here = used_here || cant_push - n_alts = length used_in_flags n_used_alts = count id used_in_flags -- returns number of Trues in list. - can_push = n_used_alts == 1 -- Used in just one branch- || (is_case && -- We are looking at case alternatives- n_used_alts > 1 && -- It's used in more than one- n_used_alts < n_alts && -- ...but not all- floatIsDupable dflags bind) -- and we can duplicate the binding+ cant_push+ | is_case = n_used_alts == n_alts -- Used in all, don't push+ -- Remember n_alts > 1+ || (n_used_alts > 1 && not (floatIsDupable dflags bind))+ -- floatIsDupable: see Note [Duplicating floats] + | otherwise = floatIsCase bind || n_used_alts > 1+ -- floatIsCase: see Note [Floating primops]+ new_boxes | drop_here = (insert here_box : fork_boxes) | otherwise = (here_box : new_fork_boxes) - new_fork_boxes = zipWithEqual "FloatIn.sepBinds" insert_maybe fork_boxes used_in_flags+ new_fork_boxes = zipWithEqual "FloatIn.sepBinds" insert_maybe+ fork_boxes used_in_flags insert :: DropBox -> DropBox insert (fvs,drops) = (fvs `unionDVarSet` bind_fvs, bind_w_fvs:drops)@@ -642,6 +725,22 @@ go _ _ = panic "sepBindsByDropPoint/go" +{- Note [Duplicating floats]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~++For case expressions we duplicate the binding if it is reasonably+small, and if it is not used in all the RHSs This is good for+situations like+ let x = I# y in+ case e of+ C -> error x+ D -> error x+ E -> ...not mentioning x...++If the thing is used in all RHSs there is nothing gained,+so we don't duplicate then.+-}+ floatedBindsFVs :: FloatInBinds -> FreeVarSet floatedBindsFVs binds = mapUnionDVarSet fbFVs binds @@ -657,3 +756,7 @@ floatIsDupable dflags (FloatCase scrut _ _ _) = exprIsDupable dflags scrut floatIsDupable dflags (FloatLet (Rec prs)) = all (exprIsDupable dflags . snd) prs floatIsDupable dflags (FloatLet (NonRec _ r)) = exprIsDupable dflags r++floatIsCase :: FloatBind -> Bool+floatIsCase (FloatCase {}) = True+floatIsCase (FloatLet {}) = False
simplCore/FloatOut.hs view
@@ -11,6 +11,8 @@ module FloatOut ( floatOutwards ) where +import GhcPrelude+ import CoreSyn import CoreUtils import MkCore@@ -21,7 +23,7 @@ import ErrUtils ( dumpIfSet_dyn ) import Id ( Id, idArity, idType, isBottomingId, isJoinId, isJoinId_maybe )-import Var ( Var )+import BasicTypes ( TopLevelFlag(..), isTopLevel ) import SetLevels import UniqSupply ( UniqSupply ) import Bag@@ -735,19 +737,26 @@ wrapTick :: Tickish Id -> FloatBinds -> FloatBinds wrapTick t (FB tops ceils defns)- = FB (mapBag wrap_bind tops) (wrap_defns ceils)- (M.map (M.map wrap_defns) defns)+ = FB (mapBag (wrap_bind TopLevel) tops)+ (wrap_defns NotTopLevel ceils)+ (M.map (M.map (wrap_defns NotTopLevel)) defns) where- wrap_defns = mapBag wrap_one+ wrap_defns toplvl = mapBag (wrap_one toplvl) - wrap_bind (NonRec binder rhs) = NonRec binder (maybe_tick rhs)- wrap_bind (Rec pairs) = Rec (mapSnd maybe_tick pairs)+ wrap_bind toplvl (NonRec binder rhs) = NonRec binder (maybe_tick toplvl rhs)+ wrap_bind toplvl (Rec pairs) = Rec (mapSnd (maybe_tick toplvl) pairs) - wrap_one (FloatLet bind) = FloatLet (wrap_bind bind)- wrap_one (FloatCase e b c bs) = FloatCase (maybe_tick e) b c bs+ wrap_one toplvl (FloatLet bind) = FloatLet (wrap_bind toplvl bind)+ wrap_one toplvl (FloatCase e b c bs) = FloatCase (maybe_tick toplvl e) b c bs - maybe_tick e | exprIsHNF e = tickHNFArgs t e- | otherwise = mkTick t e+ maybe_tick :: TopLevelFlag -> CoreExpr -> CoreExpr+ maybe_tick toplvl e+ -- We must take care not to tick top-level literal+ -- strings as this violated the Core invariants. See Note [CoreSyn+ -- top-level string literals].+ | isTopLevel toplvl && exprIsLiteralString e = e+ | exprIsHNF e = tickHNFArgs t e+ | otherwise = mkTick t e -- we don't need to wrap a tick around an HNF when we float it -- outside a tick: that is an invariant of the tick semantics -- Conversely, inlining of HNFs inside an SCC is allowed, and
simplCore/LiberateCase.hs view
@@ -9,6 +9,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags import CoreSyn import CoreUnfold ( couldBeSmallEnoughToInline )
simplCore/OccurAnal.hs view
@@ -11,7 +11,7 @@ core expression with (hopefully) improved usage information. -} -{-# LANGUAGE CPP, BangPatterns, MultiWayIf #-}+{-# LANGUAGE CPP, BangPatterns, MultiWayIf, ViewPatterns #-} module OccurAnal ( occurAnalysePgm, occurAnalyseExpr, occurAnalyseExpr_NoBinderSwap@@ -19,10 +19,13 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreFVs import CoreUtils ( exprIsTrivial, isDefaultAlt, isExpandableApp, stripTicksTopE, mkTicks )+import CoreArity ( joinRhsArity ) import Id import IdInfo import Name( localiseName )@@ -35,7 +38,7 @@ import VarEnv import Var import Demand ( argOneShots, argsOneShots )-import Digraph ( SCC(..), Node+import Digraph ( SCC(..), Node(..) , stronglyConnCompFromEdgedVerticesUniq , stronglyConnCompFromEdgedVerticesUniqR ) import Unique@@ -170,7 +173,7 @@ 4. To do so we form a new set of Nodes, with the same details, but different edges, the "loop-breaker nodes". The loop-breaker nodes- have both more and fewer depedencies than the scope edges+ have both more and fewer dependencies than the scope edges (see Note [Choosing loop breakers]) More edges: if f calls g, and g has an active rule that mentions h@@ -732,8 +735,8 @@ add this analysis if necessary. -------------------------------------------------------------Note [Adjusting for lambdas]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Note [Adjusting right-hand sides]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ There's a bit of a dance we need to do after analysing a lambda expression or a right-hand side. In particular, we need to @@ -892,7 +895,6 @@ | otherwise -- At this point we always build a single Rec = -- pprTrace "occAnalRec" (vcat -- [ text "weak_fvs" <+> ppr weak_fvs- -- , text "tagged details" <+> ppr tagged_details_s -- , text "lb nodes" <+> ppr loop_breaker_nodes]) (final_uds, Rec pairs : binds) @@ -956,7 +958,8 @@ -- Return the bindings sorted into a plausible order, and marked with loop breakers. loopBreakNodes depth bndr_set weak_fvs nodes binds- = go (stronglyConnCompFromEdgedVerticesUniqR nodes) binds+ = -- pprTrace "loopBreakNodes" (ppr nodes) $+ go (stronglyConnCompFromEdgedVerticesUniqR nodes) binds where go [] binds = binds go (scc:sccs) binds = loop_break_scc scc (go sccs binds)@@ -973,13 +976,13 @@ reOrderNodes _ _ _ [] _ = panic "reOrderNodes" reOrderNodes _ _ _ [node] binds = mk_loop_breaker node : binds reOrderNodes depth bndr_set weak_fvs (node : nodes) binds- = -- pprTrace "reOrderNodes" (text "unchosen" <+> ppr unchosen $$- -- text "chosen" <+> ppr chosen_nodes) $+ = -- pprTrace "reOrderNodes" (vcat [ text "unchosen" <+> ppr unchosen+ -- , text "chosen" <+> ppr chosen_nodes ]) $ loopBreakNodes new_depth bndr_set weak_fvs unchosen $ (map mk_loop_breaker chosen_nodes ++ binds) where (chosen_nodes, unchosen) = chooseLoopBreaker approximate_lb- (nd_score (fstOf3 node))+ (nd_score (node_payload node)) [node] [] nodes approximate_lb = depth >= 2@@ -989,14 +992,15 @@ -- and approximate, returning to d=0 mk_loop_breaker :: LetrecNode -> Binding-mk_loop_breaker (ND { nd_bndr = bndr, nd_rhs = rhs}, _, _)+mk_loop_breaker (node_payload -> ND { nd_bndr = bndr, nd_rhs = rhs}) = (bndr `setIdOccInfo` strongLoopBreaker { occ_tail = tail_info }, rhs) where tail_info = tailCallInfo (idOccInfo bndr) mk_non_loop_breaker :: VarSet -> LetrecNode -> Binding -- See Note [Weak loop breakers]-mk_non_loop_breaker weak_fvs (ND { nd_bndr = bndr, nd_rhs = rhs}, _, _)+mk_non_loop_breaker weak_fvs (node_payload -> ND { nd_bndr = bndr+ , nd_rhs = rhs}) | bndr `elemVarSet` weak_fvs = (setIdOccInfo bndr occ', rhs) | otherwise = (bndr, rhs) where@@ -1030,7 +1034,7 @@ | otherwise -- Worse score so don't pick it = chooseLoopBreaker approx_lb loop_sc loop_nodes (node : acc) nodes where- sc = nd_score (fstOf3 node)+ sc = nd_score (node_payload node) {- Note [Complexity of loop breaking]@@ -1204,6 +1208,7 @@ , text "inl =" <+> ppr (nd_inl nd) , text "weak =" <+> ppr (nd_weak nd) , text "rule =" <+> ppr (nd_active_rule_fvs nd)+ , text "score =" <+> ppr (nd_score nd) ]) -- The NodeScore is compared lexicographically;@@ -1223,7 +1228,7 @@ -> (Var, CoreExpr) -> LetrecNode -- See Note [Recursive bindings: the grand plan] makeNode env imp_rule_edges bndr_set (bndr, rhs)- = (details, varUnique bndr, nonDetKeysUniqSet node_fvs)+ = DigraphNode details (varUnique bndr) (nonDetKeysUniqSet node_fvs) -- It's OK to use nonDetKeysUniqSet here as stronglyConnCompFromEdgedVerticesR -- is still deterministic with edges in nondeterministic order as -- explained in Note [Deterministic SCC] in Digraph.@@ -1296,10 +1301,12 @@ = (final_uds, zipWith mk_lb_node details_s bndrs') where (final_uds, bndrs') = tagRecBinders lvl body_uds- [ (nd_bndr nd, nd_uds nd, nd_rhs_bndrs nd)+ [ ((nd_bndr nd)+ ,(nd_uds nd)+ ,(nd_rhs_bndrs nd)) | nd <- details_s ] mk_lb_node nd@(ND { nd_bndr = bndr, nd_rhs = rhs, nd_inl = inl_fvs }) bndr'- = (nd', varUnique bndr, nonDetKeysUniqSet lb_deps)+ = DigraphNode nd' (varUnique bndr) (nonDetKeysUniqSet lb_deps) -- It's OK to use nonDetKeysUniqSet here as -- stronglyConnCompFromEdgedVerticesR is still deterministic with edges -- in nondeterministic order as explained in@@ -1550,19 +1557,24 @@ occAnalNonRecRhs env bndr bndrs body = occAnalLamOrRhs rhs_env bndrs body where- -- See Note [Cascading inlines]- env1 | certainly_inline = env+ env1 | is_join_point = env -- See Note [Join point RHSs]+ | certainly_inline = env -- See Note [Cascading inlines] | otherwise = rhsCtxt env -- See Note [Sources of one-shot information] rhs_env = env1 { occ_one_shots = argOneShots dmd } certainly_inline -- See Note [Cascading inlines]- = case idOccInfo bndr of+ = case occ of OneOcc { occ_in_lam = in_lam, occ_one_br = one_br }- -> not in_lam && one_br && active && not_stable- _ -> False+ -> not in_lam && one_br && active && not_stable+ _ -> False + is_join_point = isAlwaysTailCalled occ+ -- Like (isJoinId bndr) but happens one step earlier+ -- c.f. willBeJoinId_maybe++ occ = idOccInfo bndr dmd = idDemandInfo bndr active = isAlwaysActive (idInlineActivation bndr) not_stable = not (isStableUnfolding (idUnfolding bndr))@@ -1623,7 +1635,18 @@ = case mb_expected_join_arity of Just ar | args `lengthIs` ar -> uds _ -> markAllNonTailCalled uds-{-+{- Note [Join point RHSs]+~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ x = e+ join j = Just x++We want to inline x into j right away, so we don't want to give+the join point a RhsCtxt (Trac #14137). It's not a huge deal, because+the FloatIn pass knows to float into join point RHSs; and the simplifier+does not float things out of join point RHSs. But it's a simple, cheap+thing to do. See Trac #14137.+ Note [Cascading inlines] ~~~~~~~~~~~~~~~~~~~~~~~~ By default we use an rhsCtxt for the RHS of a binding. This tells the@@ -1650,15 +1673,19 @@ an ordinary context, not rhsCtxt. Hence the "certainly_inline" stuff. Annoyingly, we have to approximate SimplUtils.preInlineUnconditionally.-If we say "yes" when preInlineUnconditionally says "no" the simplifier iterates-indefinitely:+If (a) the RHS is expandable (see isExpandableApp in occAnalApp), and+ (b) certainly_inline says "yes" when preInlineUnconditionally says "no"+then the simplifier iterates indefinitely: x = f y- k = Just x+ k = Just x -- We decide that k is 'certainly_inline'+ v = ...k... -- but preInlineUnconditionally doesn't inline it inline ==> k = Just (f y)+ v = ...k... float ==> x1 = f y k = Just x1+ v = ...k... This is worse than the slow cascade, so we only want to say "certainly_inline" if it really is certain. Look at the note with preInlineUnconditionally@@ -1699,6 +1726,12 @@ -} occAnal env (Tick tickish body)+ | SourceNote{} <- tickish+ = (usage, Tick tickish body')+ -- SourceNotes are best-effort; so we just proceed as usual.+ -- If we drop a tick due to the issues described below it's+ -- not the end of the world.+ | tickish `tickishScopesLike` SoftScope = (markAllNonTailCalled usage, Tick tickish body') @@ -1718,6 +1751,7 @@ -- Making j a join point may cause the simplifier to drop t -- (if the tick is put into the continuation). So we don't -- count j 1 as a tail call.+ -- See #14242. occAnal env (Cast expr co) = case occAnal env expr of { (usage, expr') ->@@ -2569,7 +2603,7 @@ Nothing -> all isOneShotBndr bndrs exact_join = case mb_join_arity of- Just join_arity -> join_arity == length bndrs+ Just join_arity -> bndrs `lengthIs` join_arity _ -> False type IdWithOccInfo = Id@@ -2606,7 +2640,8 @@ = let occ = lookupDetails usage binder will_be_join = decideJoinPointHood lvl usage [binder]- occ' | will_be_join = occ -- must already be marked AlwaysTailCalled+ occ' | will_be_join = -- must already be marked AlwaysTailCalled+ ASSERT(isAlwaysTailCalled occ) occ | otherwise = markNonTailCalled occ binder' = setBinderOcc occ' binder usage' = usage `delDetails` binder@@ -2646,19 +2681,15 @@ , AlwaysTailCalled arity <- tailCallInfo occ = Just arity | otherwise- = ASSERT(not will_be_joins) -- Should be AlwaysTailCalled if we're- -- making join points!- Nothing+ = ASSERT(not will_be_joins) -- Should be AlwaysTailCalled if+ Nothing -- we are making join points! -- 3. Compute final usage details from adjusted RHS details adj_uds = body_uds +++ combineUsageDetailsList rhs_udss' - -- 4. Tag each binder with its adjusted details modulo the- -- join-point-hood decision- occs = map (lookupDetails adj_uds) bndrs- occs' | will_be_joins = occs- | otherwise = map markNonTailCalled occs- bndrs' = zipWith setBinderOcc occs' bndrs+ -- 4. Tag each binder with its adjusted details+ bndrs' = [ setBinderOcc (lookupDetails adj_uds bndr) bndr+ | bndr <- bndrs ] -- 5. Drop the binders from the adjusted details and return usage' = adj_uds `delDetailsList` bndrs@@ -2679,10 +2710,15 @@ -- | Decide whether some bindings should be made into join points or not. -- Returns `False` if they can't be join points. Note that it's an--- all-or-nothing decision, as if multiple binders are given, they're assumed to--- be mutually recursive.+-- all-or-nothing decision, as if multiple binders are given, they're+-- assumed to be mutually recursive. ----- See Note [Invariants for join points] in CoreSyn.+-- It must, however, be a final decision. If we say "True" for 'f',+-- and then subsequently decide /not/ make 'f' into a join point, then+-- the decision about another binding 'g' might be invalidated if (say)+-- 'f' tail-calls 'g'.+--+-- See Note [Invariants on join points] in CoreSyn. decideJoinPointHood :: TopLevelFlag -> UsageDetails -> [CoreBndr] -> Bool@@ -2706,6 +2742,9 @@ AlwaysTailCalled arity <- tailCallInfo (lookupDetails usage bndr) , -- Invariant 1 as applied to LHSes of rules all (ok_rule arity) (idCoreRules bndr)+ -- Invariant 2a: stable unfoldings+ -- See Note [Join points and INLINE pragmas]+ , ok_unfolding arity (realIdUnfolding bndr) -- Invariant 4: Satisfies polymorphism rule , isValidJoinPointType arity (idType bndr) = True@@ -2714,17 +2753,55 @@ ok_rule _ BuiltinRule{} = False -- only possible with plugin shenanigans ok_rule join_arity (Rule { ru_args = args })- = length args == join_arity+ = args `lengthIs` join_arity -- Invariant 1 as applied to LHSes of rules + -- ok_unfolding returns False if we should /not/ convert a non-join-id+ -- into a join-id, even though it is AlwaysTailCalled+ ok_unfolding join_arity (CoreUnfolding { uf_src = src, uf_tmpl = rhs })+ = not (isStableSource src && join_arity > joinRhsArity rhs)+ ok_unfolding _ (DFunUnfolding {})+ = False+ ok_unfolding _ _+ = True+ willBeJoinId_maybe :: CoreBndr -> Maybe JoinArity willBeJoinId_maybe bndr- | AlwaysTailCalled arity <- tailCallInfo (idOccInfo bndr)- = Just arity- | otherwise- = isJoinId_maybe bndr+ = case tailCallInfo (idOccInfo bndr) of+ AlwaysTailCalled arity -> Just arity+ _ -> isJoinId_maybe bndr -{-++{- Note [Join points and INLINE pragmas]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ f x = let g = \x. not -- Arity 1+ {-# INLINE g #-}+ in case x of+ A -> g True True+ B -> g True False+ C -> blah2++Here 'g' is always tail-called applied to 2 args, but the stable+unfolding captured by the INLINE pragma has arity 1. If we try to+convert g to be a join point, its unfolding will still have arity 1+(since it is stable, and we don't meddle with stable unfoldings), and+Lint will complain (see Note [Invariants on join points], (2a), in+CoreSyn. Trac #13413.++Moreover, since g is going to be inlined anyway, there is no benefit+from making it a join point.++If it is recursive, and uselessly marked INLINE, this will stop us+making it a join point, which is annoying. But occasionally+(notably in class methods; see Note [Instances and loop breakers] in+TcInstDcls) we mark recursive things as INLINE but the recursion+unravels; so ignoring INLINE pragmas on recursive things isn't good+either.++See Invariant 2a of Note [Invariants on join points] in CoreSyn++ ************************************************************************ * * \subsection{Operations over OccInfo}
simplCore/SAT.hs view
@@ -51,6 +51,8 @@ {-# LANGUAGE CPP #-} module SAT ( doStaticArgs ) where +import GhcPrelude+ import Var import CoreSyn import CoreUtils
simplCore/SetLevels.hs view
@@ -62,6 +62,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreMonad ( FloatOutSwitches(..) ) import CoreUtils ( exprType, exprIsHNF@@ -79,12 +81,13 @@ import IdInfo import Var import VarSet+import UniqSet ( nonDetFoldUniqSet ) import VarEnv import Literal ( litIsTrivial )-import Demand ( StrictSig, isStrictDmd, splitStrictSig, increaseStrictSigArity )+import Demand ( StrictSig, Demand, isStrictDmd, splitStrictSig, increaseStrictSigArity ) import Name ( getOccName, mkSystemVarName ) import OccName ( occNameString )-import Type ( isUnliftedType, Type, mkLamTypes, splitTyConApp_maybe )+import Type ( Type, mkLamTypes, splitTyConApp_maybe, tyCoVarsOfType ) import BasicTypes ( Arity, RecFlag(..), isRec ) import DataCon ( dataConOrigResTy ) import TysWiredIn@@ -95,7 +98,7 @@ import UniqDFM import FV import Data.Maybe-import Control.Monad ( zipWithM )+import MonadUtils ( mapAccumLM ) {- ************************************************************************@@ -120,7 +123,7 @@ = FloatMe Level -- Float to just inside the binding -- tagged with this level | StayPut Level -- Stay where it is; binding is- -- tagged with tihs level+ -- tagged with this level floatSpecLevel :: FloatSpec -> Level floatSpecLevel (FloatMe l) = l@@ -402,7 +405,7 @@ ; return (foldl App lapp' rargs') } | otherwise- = do { args' <- zipWithM (lvlMFE env) stricts args+ = do { (_, args') <- mapAccumLM lvl_arg stricts args -- Take account of argument strictness; see -- Note [Floating to the top] ; return (foldl App (lookupVar env fn) args') }@@ -410,12 +413,12 @@ n_val_args = count (isValArg . deAnnotate) args arity = idArity fn - stricts :: [Bool] -- True for strict argument+ stricts :: [Demand] -- True for strict /value/ arguments stricts = case splitStrictSig (idStrictness fn) of- (arg_ds, _) | not (arg_ds `lengthExceeds` n_val_args)- -> map isStrictDmd arg_ds ++ repeat False+ (arg_ds, _) | arg_ds `lengthExceeds` n_val_args+ -> [] | otherwise- -> repeat False+ -> arg_ds -- Separate out the PAP that we are floating from the extra -- arguments, by traversing the spine until we have collected@@ -428,6 +431,19 @@ | otherwise = left n f (a:rargs) left _ _ _ = panic "SetLevels.lvlExpr.left" + is_val_arg :: CoreExprWithFVs -> Bool+ is_val_arg (_, AnnType {}) = False+ is_val_arg _ = True++ lvl_arg :: [Demand] -> CoreExprWithFVs -> LvlM ([Demand], LevelledExpr)+ lvl_arg strs arg | (str1 : strs') <- strs+ , is_val_arg arg+ = do { arg' <- lvlMFE env (isStrictDmd str1) arg+ ; return (strs', arg') }+ | otherwise+ = do { arg' <- lvlMFE env False arg+ ; return (strs, arg') }+ lvlApp env _ (fun, args) = -- No PAPs that we can float: just carry on with the -- arguments and the function.@@ -516,7 +532,7 @@ in this case), not the *input* one 'y'. The latter *is* ok for speculation here, but the former is not -- and indeed we can't float the inner case out, at least not unless x is also evaluated at its-binding site.+binding site. See Trac #5453. That's why we apply exprOkForSpeculation to scrut' and not to scrut. -}@@ -614,13 +630,14 @@ expr = deAnnotate ann_expr expr_ty = exprType expr fvs = freeVarsOf ann_expr+ fvs_ty = tyCoVarsOfType expr_ty is_bot = isBottomThunk mb_bot_str is_function = isFunction ann_expr mb_bot_str = exprBotStrictness_maybe expr -- See Note [Bottoming floats] -- esp Bottoming floats (2) expr_ok_for_spec = exprOkForSpeculation expr- dest_lvl = destLevel env fvs is_function is_bot False+ dest_lvl = destLevel env fvs fvs_ty is_function is_bot False abs_vars = abstractVars dest_lvl env fvs -- float_is_new_lam: the floated thing will be a new value lambda@@ -895,7 +912,17 @@ by 7% in spectral/puzzle (a rather strange benchmark) and 1.2% in real/fem. Doesn't change any other allocation at all. -We will make a separate decision for the scrutinees and alternatives.+We will make a separate decision for the scrutinee and alternatives.++However this can have a knock-on effect for fusion: consider+ \v -> foldr k z (case x of I# y -> build ..y..)+Perhaps we can float the entire (case x of ...) out of the \v. Then+fusion will not happen, but we will get more sharing. But if we don't+float the case (as advocated here) we won't float the (build ...y..)+either, so fusion will happen. It can be a big effect, esp in some+artificial benchmarks (e.g. integer, queens), but there is no perfect+answer.+ -} annotateBotStr :: Id -> Arity -> Maybe (Arity, StrictSig) -> Id@@ -1003,10 +1030,10 @@ || isCoVar bndr -- Difficult to fix up CoVar occurrences (see extendPolyLvlEnv) -- so we will ignore this case for now || not (profitableFloat env dest_lvl)- || (isTopLvl dest_lvl && isUnliftedType (idType bndr))- -- We can't float an unlifted binding to top level, so we don't- -- float it at all. It's a bit brutal, but unlifted bindings- -- aren't expensive either+ || (isTopLvl dest_lvl && not (exprIsTopLevelBindable deann_rhs bndr_ty))+ -- We can't float an unlifted binding to top level (except+ -- literal strings), so we don't float it at all. It's a+ -- bit brutal, but unlifted bindings aren't expensive either = -- No float do { rhs' <- lvlRhs env NonRecursive is_bot mb_join_arity rhs@@ -1032,12 +1059,15 @@ ; return (NonRec (TB bndr2 (FloatMe dest_lvl)) rhs', env') } where+ bndr_ty = idType bndr+ ty_fvs = tyCoVarsOfType bndr_ty rhs_fvs = freeVarsOf rhs bind_fvs = rhs_fvs `unionDVarSet` dIdFreeVars bndr abs_vars = abstractVars dest_lvl env bind_fvs- dest_lvl = destLevel env bind_fvs (isFunction rhs) is_bot is_join+ dest_lvl = destLevel env bind_fvs ty_fvs (isFunction rhs) is_bot is_join - mb_bot_str = exprBotStrictness_maybe (deAnnotate rhs)+ deann_rhs = deAnnotate rhs+ mb_bot_str = exprBotStrictness_maybe deann_rhs is_bot = isJust mb_bot_str -- NB: not isBottomThunk! See Note [Bottoming floats] point (3) @@ -1125,7 +1155,8 @@ `delDVarSetList` bndrs - dest_lvl = destLevel env bind_fvs is_fun is_bot is_join+ ty_fvs = foldr (unionVarSet . tyCoVarsOfType . idType) emptyVarSet bndrs+ dest_lvl = destLevel env bind_fvs ty_fvs is_fun is_bot is_join abs_vars = abstractVars dest_lvl env bind_fvs profitableFloat :: LevelEnv -> Level -> Bool@@ -1288,13 +1319,16 @@ -- Destination level is the max Id level of the expression -- (We'll abstract the type variables, if any.)-destLevel :: LevelEnv -> DVarSet+destLevel :: LevelEnv+ -> DVarSet -- Free vars of the term+ -> TyCoVarSet -- Free in the /type/ of the term+ -- (a subset of the previous argument) -> Bool -- True <=> is function -> Bool -- True <=> is bottom -> Bool -- True <=> is a join point -> Level -- INVARIANT: if is_join=True then result >= join_ceiling-destLevel env fvs is_function is_bot is_join+destLevel env fvs fvs_ty is_function is_bot is_join | isTopLvl max_fv_id_level -- Float even joins if they get to top level -- See Note [Floating join point bindings] = tOP_LEVEL@@ -1306,22 +1340,49 @@ else max_fv_id_level | is_bot -- Send bottoming bindings to the top- = tOP_LEVEL -- regardless; see Note [Bottoming floats]+ = as_far_as_poss -- regardless; see Note [Bottoming floats] -- Esp Bottoming floats (1) | Just n_args <- floatLams env , n_args > 0 -- n=0 case handled uniformly by the 'otherwise' case , is_function , countFreeIds fvs <= n_args- = tOP_LEVEL -- Send functions to top level; see- -- the comments with isFunction+ = as_far_as_poss -- Send functions to top level; see+ -- the comments with isFunction | otherwise = max_fv_id_level where- max_fv_id_level = maxFvLevel isId env fvs -- Max over Ids only; the tyvars- -- will be abstracted- join_ceiling = joinCeilingLevel env+ join_ceiling = joinCeilingLevel env+ max_fv_id_level = maxFvLevel isId env fvs -- Max over Ids only; the+ -- tyvars will be abstracted + as_far_as_poss = maxFvLevel' isId env fvs_ty+ -- See Note [Floating and kind casts]++{- Note [Floating and kind casts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this+ case x of+ K (co :: * ~# k) -> let v :: Int |> co+ v = e+ in blah++Then, even if we are abstracting over Ids, or if e is bottom, we can't+float v outside the 'co' binding. Reason: if we did we'd get+ v' :: forall k. (Int ~# Age) => Int |> co+and now 'co' isn't in scope in that type. The underlying reason is+that 'co' is a value-level thing and we can't abstract over that in a+type (else we'd get a dependent type). So if v's /type/ mentions 'co'+we can't float it out beyond the binding site of 'co'.++That's why we have this as_far_as_poss stuff. Usually as_far_as_poss+is just tOP_LEVEL; but occasionally a coercion variable (which is an+Id) mentioned in type prevents this.++Example Trac #14270 comment:15.+-}++ isFunction :: CoreExprWithFVs -> Bool -- The idea here is that we want to float *functions* to -- the top level. This saves no work, but@@ -1454,14 +1515,20 @@ lvl' = asJoinCeilLvl (incMinorLvl lvl) maxFvLevel :: (Var -> Bool) -> LevelEnv -> DVarSet -> Level-maxFvLevel max_me (LE { le_lvl_env = lvl_env, le_env = id_env }) var_set- = foldDVarSet max_in tOP_LEVEL var_set- where- max_in in_var lvl- = foldr max_out lvl (case lookupVarEnv id_env in_var of- Just (abs_vars, _) -> abs_vars- Nothing -> [in_var])+maxFvLevel max_me env var_set+ = foldDVarSet (maxIn max_me env) tOP_LEVEL var_set +maxFvLevel' :: (Var -> Bool) -> LevelEnv -> TyCoVarSet -> Level+-- Same but for TyCoVarSet+maxFvLevel' max_me env var_set+ = nonDetFoldUniqSet (maxIn max_me env) tOP_LEVEL var_set++maxIn :: (Var -> Bool) -> LevelEnv -> InVar -> Level -> Level+maxIn max_me (LE { le_lvl_env = lvl_env, le_env = id_env }) in_var lvl+ = case lookupVarEnv id_env in_var of+ Just (abs_vars, _) -> foldr max_out lvl abs_vars+ Nothing -> max_out in_var lvl+ where max_out out_var lvl | max_me out_var = case lookupVarEnv lvl_env out_var of Just lvl' -> maxLvl lvl' lvl
simplCore/SimplCore.hs view
@@ -10,6 +10,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags import CoreSyn import HscTypes@@ -43,6 +45,7 @@ import SpecConstr ( specConstrProgram) import DmdAnal ( dmdAnalProgram ) import CallArity ( callArityAnalProgram )+import Exitify ( exitifyProgram ) import WorkWrap ( wwTopBinds ) import Vectorise ( vectorise ) import SrcLoc@@ -56,7 +59,7 @@ import Control.Monad import qualified GHC.LanguageExtensions as LangExt -#ifdef GHCI+#if defined(GHCI) import DynamicLoading ( loadPlugins ) import Plugins ( installCoreToDos ) #else@@ -120,6 +123,7 @@ max_iter = maxSimplIterations dflags rule_check = ruleCheck dflags call_arity = gopt Opt_CallArity dflags+ exitification = gopt Opt_Exitification dflags strictness = gopt Opt_Strictness dflags full_laziness = gopt Opt_FullLaziness dflags do_specialise = gopt Opt_Specialise dflags@@ -142,6 +146,7 @@ base_mode = SimplMode { sm_phase = panic "base_mode" , sm_names = []+ , sm_dflags = dflags , sm_rules = rules_on , sm_eta_expand = eta_expand_on , sm_inline = True@@ -284,7 +289,7 @@ -- At least 3 iterations because otherwise we land up with -- huge dead expressions because of an infelicity in the- -- simpifier.+ -- simplifier. -- let k = BIG in foldr k z xs -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs@@ -305,6 +310,9 @@ runWhen strictness demand_analyser, + runWhen exitification CoreDoExitify,+ -- See note [Placement of the exitification pass]+ runWhen full_laziness $ CoreDoFloatOutwards FloatOutSwitches { floatOutLambdas = floatLamArgs dflags,@@ -368,7 +376,7 @@ -- Loading plugins addPluginPasses :: [CoreToDo] -> CoreM [CoreToDo]-#ifndef GHCI+#if !defined(GHCI) addPluginPasses builtin_passes = do { dflags <- getDynFlags ; let pluginMods = pluginModNames dflags@@ -473,6 +481,9 @@ doCorePass CoreDoCallArity = {-# SCC "CallArity" #-} doPassD callArityAnalProgram +doCorePass CoreDoExitify = {-# SCC "Exitify" #-}+ doPass exitifyProgram+ doCorePass CoreDoStrictness = {-# SCC "NewStranal" #-} doPassDFM dmdAnalProgram @@ -493,7 +504,7 @@ doCorePass CoreDoNothing = return doCorePass (CoreDoPasses passes) = runCorePasses passes -#ifdef GHCI+#if defined(GHCI) doCorePass (CoreDoPluginPass _ pass) = {-# SCC "Plugin" #-} pass #endif @@ -619,7 +630,7 @@ -- (b) the LHS and RHS of a RULE -- (c) Template Haskell splices ----- The name 'Gently' suggests that the SimplifierMode is SimplGently,+-- The name 'Gently' suggests that the SimplMode is SimplGently, -- and in fact that is so.... but the 'Gently' in simplExprGently doesn't -- enforce that; it just simplifies the expression twice @@ -754,8 +765,8 @@ -- Simplify the program ((binds1, rules1), counts1) <- initSmpl dflags (mkRuleEnv rule_base2 vis_orphs) fam_envs us1 sz $- do { env1 <- {-# SCC "SimplTopBinds" #-}- simplTopBinds simpl_env tagged_binds+ do { (floats, env1) <- {-# SCC "SimplTopBinds" #-}+ simplTopBinds simpl_env tagged_binds -- Apply the substitution to rules defined in this module -- for imported Ids. Eg RULE map my_f = blah@@ -763,7 +774,7 @@ -- apply it to the rule to, or it'll never match ; rules1 <- simplRules env1 Nothing rules - ; return (getFloatBinds env1, rules1) } ;+ ; return (getTopFloatBinds floats, rules1) } ; -- Stop if nothing happened; don't dump output if isZeroSimplCount counts1 then
simplCore/SimplEnv.hs view
@@ -8,20 +8,19 @@ module SimplEnv ( -- * The simplifier mode- setMode, getMode, updMode,+ setMode, getMode, updMode, seDynFlags, -- * Environments- SimplEnv(..), StaticEnv, pprSimplEnv, -- Temp not abstract+ SimplEnv(..), pprSimplEnv, -- Temp not abstract mkSimplEnv, extendIdSubst, SimplEnv.extendTvSubst, SimplEnv.extendCvSubst, zapSubstEnv, setSubstEnv,- getInScope, setInScopeAndZapFloats,+ getInScope, setInScopeFromE, setInScopeFromF, setInScopeSet, modifyInScope, addNewInScopeIds, getSimplRules, -- * Substitution results SimplSR(..), mkContEx, substId, lookupRecBndr, refineFromInScope,- isJoinIdInEnv_maybe, -- * Simplifying 'Id' binders simplNonRecBndr, simplNonRecJoinBndr, simplRecBndrs, simplRecJoinBndrs,@@ -30,19 +29,26 @@ substCo, substCoVar, -- * Floats- Floats, emptyFloats, isEmptyFloats,- addNonRec, addFloats, extendFloats,- wrapFloats, setFloats, zapFloats, addRecFloats, mapFloats,- doFloatFromRhs, getFloatBinds,+ SimplFloats(..), emptyFloats, mkRecFloats,+ mkFloatBind, addLetFloats, addJoinFloats, addFloats,+ extendFloats, wrapFloats,+ doFloatFromRhs, getTopFloatBinds, - JoinFloats, emptyJoinFloats, isEmptyJoinFloats,- wrapJoinFloats, zapJoinFloats, restoreJoinFloats, getJoinFloatBinds,+ -- * LetFloats+ LetFloats, letFloatBinds, emptyLetFloats, unitLetFloat,+ addLetFlts, mapLetFloats,++ -- * JoinFloats+ JoinFloat, JoinFloats, emptyJoinFloats,+ wrapJoinFloats, wrapJoinFloatsX, unitJoinFloat, addJoinFlts ) where #include "HsVersions.h" +import GhcPrelude+ import SimplMonad-import CoreMonad ( SimplifierMode(..) )+import CoreMonad ( SimplMode(..) ) import CoreSyn import CoreUtils import Var@@ -51,6 +57,7 @@ import OrdList import Id import MkCore ( mkWildValBinder )+import DynFlags ( DynFlags ) import TysWiredIn import qualified Type import Type hiding ( substTy, substTyVar, substTyVarBndr )@@ -78,12 +85,12 @@ -- Static in the sense of lexically scoped, -- wrt the original expression - seMode :: SimplifierMode,+ seMode :: SimplMode -- The current substitution- seTvSubst :: TvSubstEnv, -- InTyVar |--> OutType- seCvSubst :: CvSubstEnv, -- InCoVar |--> OutCoercion- seIdSubst :: SimplIdSubst, -- InId |--> OutExpr+ , seTvSubst :: TvSubstEnv -- InTyVar |--> OutType+ , seCvSubst :: CvSubstEnv -- InCoVar |--> OutCoercion+ , seIdSubst :: SimplIdSubst -- InId |--> OutExpr ----------- Dynamic part of the environment ----------- -- Dynamic in the sense of describing the setup where@@ -91,16 +98,41 @@ -- The current set of in-scope variables -- They are all OutVars, and all bound in this module- seInScope :: InScopeSet, -- OutVars only- -- Includes all variables bound by seFloats- seFloats :: Floats,- -- See Note [Simplifier floats]- seJoinFloats :: JoinFloats- -- Handled separately; they don't go very far+ , seInScope :: InScopeSet -- OutVars only } -type StaticEnv = SimplEnv -- Just the static part is relevant+data SimplFloats+ = SimplFloats+ { -- Ordinary let bindings+ sfLetFloats :: LetFloats+ -- See Note [LetFloats] + -- Join points+ , sfJoinFloats :: JoinFloats+ -- Handled separately; they don't go very far+ -- We consider these to be /inside/ sfLetFloats+ -- because join points can refer to ordinary bindings,+ -- but not vice versa++ -- Includes all variables bound by sfLetFloats and+ -- sfJoinFloats, plus at least whatever is in scope where+ -- these bindings land up.+ , sfInScope :: InScopeSet -- All OutVars+ }++instance Outputable SimplFloats where+ ppr (SimplFloats { sfLetFloats = lf, sfJoinFloats = jf, sfInScope = is })+ = text "SimplFloats"+ <+> braces (vcat [ text "lets: " <+> ppr lf+ , text "joins:" <+> ppr jf+ , text "in_scope:" <+> ppr is ])++emptyFloats :: SimplEnv -> SimplFloats+emptyFloats env+ = SimplFloats { sfLetFloats = emptyLetFloats+ , sfJoinFloats = emptyJoinFloats+ , sfInScope = seInScope env }+ pprSimplEnv :: SimplEnv -> SDoc -- Used for debugging; selective pprSimplEnv env@@ -110,33 +142,45 @@ text "InScope:" <+> in_scope_vars_doc ] where- id_subst_doc = pprUniqFM ppr_id_subst (seIdSubst env)- ppr_id_subst (m_ar, sr) = arity_part <+> ppr sr- where arity_part = case m_ar of Just ar -> brackets $- text "join" <+> int ar- Nothing -> empty-+ id_subst_doc = pprUniqFM ppr (seIdSubst env) in_scope_vars_doc = pprVarSet (getInScopeVars (seInScope env)) (vcat . map ppr_one) ppr_one v | isId v = ppr v <+> ppr (idUnfolding v) | otherwise = ppr v -type SimplIdSubst = IdEnv (Maybe JoinArity, SimplSR) -- IdId |--> OutExpr+type SimplIdSubst = IdEnv SimplSR -- IdId |--> OutExpr -- See Note [Extending the Subst] in CoreSubst- -- See Note [Join arity in SimplIdSubst] -- | A substitution result. data SimplSR- = DoneEx OutExpr -- Completed term- | DoneId OutId -- Completed term variable- | ContEx TvSubstEnv -- A suspended substitution+ = DoneEx OutExpr (Maybe JoinArity)+ -- If x :-> DoneEx e ja is in the SimplIdSubst+ -- then replace occurrences of x by e+ -- and ja = Just a <=> x is a join-point of arity a+ -- See Note [Join arity in SimplIdSubst]+++ | DoneId OutId+ -- If x :-> DoneId v is in the SimplIdSubst+ -- then replace occurrences of x by v+ -- and v is a join-point of arity a+ -- <=> x is a join-point of arity a++ | ContEx TvSubstEnv -- A suspended substitution CvSubstEnv SimplIdSubst InExpr+ -- If x :-> ContEx tv cv id e is in the SimplISubst+ -- then replace occurrences of x by (subst (tv,cv,id) e) instance Outputable SimplSR where- ppr (DoneEx e) = text "DoneEx" <+> ppr e- ppr (DoneId v) = text "DoneId" <+> ppr v+ ppr (DoneId v) = text "DoneId" <+> ppr v+ ppr (DoneEx e mj) = text "DoneEx" <> pp_mj <+> ppr e+ where+ pp_mj = case mj of+ Nothing -> empty+ Just n -> parens (int n)+ ppr (ContEx _tv _cv _id e) = vcat [text "ContEx" <+> ppr e {-, ppr (filter_env tv), ppr (filter_env id) -}] -- where@@ -211,25 +255,21 @@ Note [Join arity in SimplIdSubst] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We have to remember which incoming variables are join points: the occurrences+may not be marked correctly yet, and we're in change of propagating the change if+OccurAnal makes something a join point). -We have to remember which incoming variables are join points (the occurrences-may not be marked correctly yet; we're in change of propagating the change if-OccurAnal makes something a join point). Normally the in-scope set is where we-keep the latest information, but the in-scope set tracks only OutVars; if a-binding is unconditionally inlined, it never makes it into the in-scope set,-and we need to know at the occurrence site that the variable is a join point so-that we know to drop the context. Thus we remember which join points we're-substituting. Clumsily, finding whether an InVar is a join variable may require-looking in both the substitution *and* the in-scope set (see-'isJoinIdInEnv_maybe').--}+Normally the in-scope set is where we keep the latest information, but+the in-scope set tracks only OutVars; if a binding is unconditionally+inlined (via DoneEx), it never makes it into the in-scope set, and we+need to know at the occurrence site that the variable is a join point+so that we know to drop the context. Thus we remember which join+points we're substituting. -} -mkSimplEnv :: SimplifierMode -> SimplEnv+mkSimplEnv :: SimplMode -> SimplEnv mkSimplEnv mode = SimplEnv { seMode = mode , seInScope = init_in_scope- , seFloats = emptyFloats- , seJoinFloats = emptyJoinFloats , seTvSubst = emptyVarEnv , seCvSubst = emptyVarEnv , seIdSubst = emptyVarEnv }@@ -249,7 +289,7 @@ way to do that is to start of with a representative Id in the in-scope set -There can be be *occurrences* of wild-id. For example,+There can be *occurrences* of wild-id. For example, MkCore.mkCoreApp transforms e (a /# b) --> case (a /# b) of wild { DEFAULT -> e wild } This is ok provided 'wild' isn't free in 'e', and that's the delicate@@ -259,20 +299,23 @@ It's a very dark corner of GHC. Maybe it should be cleaned up. -} -getMode :: SimplEnv -> SimplifierMode+getMode :: SimplEnv -> SimplMode getMode env = seMode env -setMode :: SimplifierMode -> SimplEnv -> SimplEnv+seDynFlags :: SimplEnv -> DynFlags+seDynFlags env = sm_dflags (seMode env)++setMode :: SimplMode -> SimplEnv -> SimplEnv setMode mode env = env { seMode = mode } -updMode :: (SimplifierMode -> SimplifierMode) -> SimplEnv -> SimplEnv+updMode :: (SimplMode -> SimplMode) -> SimplEnv -> SimplEnv updMode upd env = env { seMode = upd (seMode env) } --------------------- extendIdSubst :: SimplEnv -> Id -> SimplSR -> SimplEnv extendIdSubst env@(SimplEnv {seIdSubst = subst}) var res = ASSERT2( isId var && not (isCoVar var), ppr var )- env { seIdSubst = extendVarEnv subst var (isJoinId_maybe var, res) }+ env { seIdSubst = extendVarEnv subst var res } extendTvSubst :: SimplEnv -> TyVar -> Type -> SimplEnv extendTvSubst env@(SimplEnv {seTvSubst = tsubst}) var res@@ -291,26 +334,12 @@ setInScopeSet :: SimplEnv -> InScopeSet -> SimplEnv setInScopeSet env in_scope = env {seInScope = in_scope} -setInScopeAndZapFloats :: SimplEnv -> SimplEnv -> SimplEnv--- Set the in-scope set, and *zap* the floats-setInScopeAndZapFloats env env_with_scope- = env { seInScope = seInScope env_with_scope,- seFloats = emptyFloats,- seJoinFloats = emptyJoinFloats }--setFloats :: SimplEnv -> SimplEnv -> SimplEnv--- Set the in-scope set *and* the floats-setFloats env env_with_floats- = env { seInScope = seInScope env_with_floats,- seFloats = seFloats env_with_floats,- seJoinFloats = seJoinFloats env_with_floats }+setInScopeFromE :: SimplEnv -> SimplEnv -> SimplEnv+-- See Note [Setting the right in-scope set]+setInScopeFromE rhs_env here_env = rhs_env { seInScope = seInScope here_env } -restoreJoinFloats :: SimplEnv -> SimplEnv -> SimplEnv--- Put back floats previously zapped--- Unlike 'setFloats', does *not* update the in-scope set, since the right-hand--- env is assumed to be *older*-restoreJoinFloats env old_env- = env { seJoinFloats = seJoinFloats old_env }+setInScopeFromF :: SimplEnv -> SimplFloats -> SimplEnv+setInScopeFromF env floats = env { seInScope = sfInScope floats } addNewInScopeIds :: SimplEnv -> [CoreBndr] -> SimplEnv -- The new Ids are guaranteed to be freshly allocated@@ -330,6 +359,30 @@ modifyInScope env@(SimplEnv {seInScope = in_scope}) v = env {seInScope = extendInScopeSet in_scope v} +{- Note [Setting the right in-scope set]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ \x. (let x = e in b) arg[x]+where the let shadows the lambda. Really this means something like+ \x1. (let x2 = e in b) arg[x1]++- When we capture the 'arg' in an ApplyToVal continuation, we capture+ the environment, which says what 'x' is bound to, namely x1++- Then that continuation gets pushed under the let++- Finally we simplify 'arg'. We want+ - the static, lexical environment bindig x :-> x1+ - the in-scopeset from "here", under the 'let' which includes+ both x1 and x2++It's important to have the right in-scope set, else we may rename a+variable to one that is already in scope. So we must pick up the+in-scope set from "here", but otherwise use the environment we+captured along with 'arg'. This transfer of in-scope set is done by+setInScopeFromE.+-}+ --------------------- zapSubstEnv :: SimplEnv -> SimplEnv zapSubstEnv env = env {seTvSubst = emptyVarEnv, seCvSubst = emptyVarEnv, seIdSubst = emptyVarEnv}@@ -343,13 +396,13 @@ {- ************************************************************************ * *-\subsection{Floats}+\subsection{LetFloats} * * ************************************************************************ -Note [Simplifier floats]-~~~~~~~~~~~~~~~~~~~~~~~~~-The Floats is a bunch of bindings, classified by a FloatFlag.+Note [LetFloats]+~~~~~~~~~~~~~~~~+The LetFloats is a bunch of bindings, classified by a FloatFlag. * All of them satisfy the let/app invariant @@ -368,10 +421,11 @@ NonRec x# (f y) -- Might diverge; does not satisfy let/app -} -data Floats = Floats (OrdList OutBind) FloatFlag- -- See Note [Simplifier floats]+data LetFloats = LetFloats (OrdList OutBind) FloatFlag+ -- See Note [LetFloats] -type JoinFloats = OrdList OutBind+type JoinFloat = OutBind+type JoinFloats = OrdList JoinFloat data FloatFlag = FltLifted -- All bindings are lifted and lazy *or*@@ -390,12 +444,12 @@ -- and not guaranteed cheap -- Do not float these bindings out of a lazy let -instance Outputable Floats where- ppr (Floats binds ff) = ppr ff $$ ppr (fromOL binds)+instance Outputable LetFloats where+ ppr (LetFloats binds ff) = ppr ff $$ ppr (fromOL binds) instance Outputable FloatFlag where- ppr FltLifted = text "FltLifted"- ppr FltOkSpec = text "FltOkSpec"+ ppr FltLifted = text "FltLifted"+ ppr FltOkSpec = text "FltOkSpec" ppr FltCareful = text "FltCareful" andFF :: FloatFlag -> FloatFlag -> FloatFlag@@ -404,9 +458,9 @@ andFF FltOkSpec _ = FltOkSpec andFF FltLifted flt = flt -doFloatFromRhs :: TopLevelFlag -> RecFlag -> Bool -> OutExpr -> SimplEnv -> Bool+doFloatFromRhs :: TopLevelFlag -> RecFlag -> Bool -> SimplFloats -> OutExpr -> Bool -- If you change this function look also at FloatIn.noFloatFromRhs-doFloatFromRhs lvl rec str rhs (SimplEnv {seFloats = Floats fs ff})+doFloatFromRhs lvl rec str (SimplFloats { sfLetFloats = LetFloats fs ff }) rhs = not (isNilOL fs) && want_to_float && can_float where want_to_float = isTopLevel lvl || exprIsCheap rhs || exprIsExpandable rhs@@ -428,16 +482,16 @@ so we must take the 'or' of the two. -} -emptyFloats :: Floats-emptyFloats = Floats nilOL FltLifted+emptyLetFloats :: LetFloats+emptyLetFloats = LetFloats nilOL FltLifted emptyJoinFloats :: JoinFloats emptyJoinFloats = nilOL -unitFloat :: OutBind -> Floats+unitLetFloat :: OutBind -> LetFloats -- This key function constructs a singleton float with the right form-unitFloat bind = ASSERT(all (not . isJoinId) (bindersOf bind))- Floats (unitOL bind) (flag bind)+unitLetFloat bind = ASSERT(all (not . isJoinId) (bindersOf bind))+ LetFloats (unitOL bind) (flag bind) where flag (Rec {}) = FltLifted flag (NonRec bndr rhs)@@ -454,112 +508,132 @@ unitJoinFloat bind = ASSERT(all isJoinId (bindersOf bind)) unitOL bind -addNonRec :: SimplEnv -> OutId -> OutExpr -> SimplEnv--- Add a non-recursive binding and extend the in-scope set--- The latter is important; the binder may already be in the--- in-scope set (although it might also have been created with newId)--- but it may now have more IdInfo-addNonRec env id rhs- = id `seq` -- This seq forces the Id, and hence its IdInfo,- -- and hence any inner substitutions- env { seFloats = floats',- seJoinFloats = jfloats',- seInScope = extendInScopeSet (seInScope env) id }+mkFloatBind :: SimplEnv -> OutBind -> (SimplFloats, SimplEnv)+-- Make a singleton SimplFloats, and+-- extend the incoming SimplEnv's in-scope set with its binders+-- These binders may already be in the in-scope set,+-- but may have by now been augmented with more IdInfo+mkFloatBind env bind+ = (floats, env { seInScope = in_scope' }) where- bind = NonRec id rhs+ floats+ | isJoinBind bind+ = SimplFloats { sfLetFloats = emptyLetFloats+ , sfJoinFloats = unitJoinFloat bind+ , sfInScope = in_scope' }+ | otherwise+ = SimplFloats { sfLetFloats = unitLetFloat bind+ , sfJoinFloats = emptyJoinFloats+ , sfInScope = in_scope' } - floats' | isJoinId id = seFloats env- | otherwise = seFloats env `addFlts` unitFloat bind- jfloats' | isJoinId id = seJoinFloats env `addJoinFlts` unitJoinFloat bind- | otherwise = seJoinFloats env+ in_scope' = seInScope env `extendInScopeSetBind` bind -extendFloats :: SimplEnv -> OutBind -> SimplEnv--- Add these bindings to the floats, and extend the in-scope env too-extendFloats env bind- = ASSERT(all (not . isJoinId) (bindersOf bind))- env { seFloats = floats',- seJoinFloats = jfloats',- seInScope = extendInScopeSetList (seInScope env) bndrs }+extendFloats :: SimplFloats -> OutBind -> SimplFloats+-- Add this binding to the floats, and extend the in-scope env too+extendFloats (SimplFloats { sfLetFloats = floats+ , sfJoinFloats = jfloats+ , sfInScope = in_scope })+ bind+ | isJoinBind bind+ = SimplFloats { sfInScope = in_scope'+ , sfLetFloats = floats+ , sfJoinFloats = jfloats' }+ | otherwise+ = SimplFloats { sfInScope = in_scope'+ , sfLetFloats = floats'+ , sfJoinFloats = jfloats } where- bndrs = bindersOf bind+ in_scope' = in_scope `extendInScopeSetBind` bind+ floats' = floats `addLetFlts` unitLetFloat bind+ jfloats' = jfloats `addJoinFlts` unitJoinFloat bind - floats' | isJoinBind bind = seFloats env- | otherwise = seFloats env `addFlts` unitFloat bind- jfloats' | isJoinBind bind = seJoinFloats env `addJoinFlts`- unitJoinFloat bind- | otherwise = seJoinFloats env+addLetFloats :: SimplFloats -> LetFloats -> SimplFloats+-- Add the let-floats for env2 to env1;+-- *plus* the in-scope set for env2, which is bigger+-- than that for env1+addLetFloats floats let_floats@(LetFloats binds _)+ = floats { sfLetFloats = sfLetFloats floats `addLetFlts` let_floats+ , sfInScope = foldlOL extendInScopeSetBind+ (sfInScope floats) binds } -addFloats :: SimplEnv -> SimplEnv -> SimplEnv--- Add the floats for env2 to env1;+addJoinFloats :: SimplFloats -> JoinFloats -> SimplFloats+addJoinFloats floats join_floats+ = floats { sfJoinFloats = sfJoinFloats floats `addJoinFlts` join_floats+ , sfInScope = foldlOL extendInScopeSetBind+ (sfInScope floats) join_floats }++extendInScopeSetBind :: InScopeSet -> CoreBind -> InScopeSet+extendInScopeSetBind in_scope bind+ = extendInScopeSetList in_scope (bindersOf bind)++addFloats :: SimplFloats -> SimplFloats -> SimplFloats+-- Add both let-floats and join-floats for env2 to env1; -- *plus* the in-scope set for env2, which is bigger -- than that for env1-addFloats env1 env2- = env1 {seFloats = seFloats env1 `addFlts` seFloats env2,- seJoinFloats = seJoinFloats env1 `addJoinFlts` seJoinFloats env2,- seInScope = seInScope env2 }+addFloats (SimplFloats { sfLetFloats = lf1, sfJoinFloats = jf1 })+ (SimplFloats { sfLetFloats = lf2, sfJoinFloats = jf2, sfInScope = in_scope })+ = SimplFloats { sfLetFloats = lf1 `addLetFlts` lf2+ , sfJoinFloats = jf1 `addJoinFlts` jf2+ , sfInScope = in_scope } -addFlts :: Floats -> Floats -> Floats-addFlts (Floats bs1 l1) (Floats bs2 l2)- = Floats (bs1 `appOL` bs2) (l1 `andFF` l2)+addLetFlts :: LetFloats -> LetFloats -> LetFloats+addLetFlts (LetFloats bs1 l1) (LetFloats bs2 l2)+ = LetFloats (bs1 `appOL` bs2) (l1 `andFF` l2) +letFloatBinds :: LetFloats -> [CoreBind]+letFloatBinds (LetFloats bs _) = fromOL bs+ addJoinFlts :: JoinFloats -> JoinFloats -> JoinFloats addJoinFlts = appOL -zapFloats :: SimplEnv -> SimplEnv-zapFloats env = env { seFloats = emptyFloats- , seJoinFloats = emptyJoinFloats }--zapJoinFloats :: SimplEnv -> SimplEnv-zapJoinFloats env = env { seJoinFloats = emptyJoinFloats }--addRecFloats :: SimplEnv -> SimplEnv -> SimplEnv+mkRecFloats :: SimplFloats -> SimplFloats -- Flattens the floats from env2 into a single Rec group,--- prepends the floats from env1, and puts the result back in env2--- This is all very specific to the way recursive bindings are--- handled; see Simplify.simplRecBind-addRecFloats env1 env2@(SimplEnv {seFloats = Floats bs ff- ,seJoinFloats = jbs })+-- They must either all be lifted LetFloats or all JoinFloats+mkRecFloats floats@(SimplFloats { sfLetFloats = LetFloats bs ff+ , sfJoinFloats = jbs+ , sfInScope = in_scope }) = ASSERT2( case ff of { FltLifted -> True; _ -> False }, ppr (fromOL bs) )- env2 {seFloats = seFloats env1 `addFlts` floats'- ,seJoinFloats = seJoinFloats env1 `addJoinFlts` jfloats'}+ ASSERT2( isNilOL bs || isNilOL jbs, ppr floats )+ SimplFloats { sfLetFloats = floats'+ , sfJoinFloats = jfloats'+ , sfInScope = in_scope } where- floats' | isNilOL bs = emptyFloats- | otherwise = unitFloat (Rec (flattenBinds (fromOL bs)))+ floats' | isNilOL bs = emptyLetFloats+ | otherwise = unitLetFloat (Rec (flattenBinds (fromOL bs))) jfloats' | isNilOL jbs = emptyJoinFloats | otherwise = unitJoinFloat (Rec (flattenBinds (fromOL jbs))) -wrapFloats :: SimplEnv -> OutExpr -> OutExpr+wrapFloats :: SimplFloats -> OutExpr -> OutExpr -- Wrap the floats around the expression; they should all -- satisfy the let/app invariant, so mkLets should do the job just fine-wrapFloats env@(SimplEnv {seFloats = Floats bs _}) body- = foldrOL Let (wrapJoinFloats env body) bs- -- Note: Always safe to put the joins on the inside since the values- -- can't refer to them--wrapJoinFloats :: SimplEnv -> OutExpr -> OutExpr-wrapJoinFloats (SimplEnv {seJoinFloats = jbs}) body- = foldrOL Let body jbs--getFloatBinds :: SimplEnv -> [CoreBind]-getFloatBinds env@(SimplEnv {seFloats = Floats bs _})- = fromOL bs ++ getJoinFloatBinds env+wrapFloats (SimplFloats { sfLetFloats = LetFloats bs _+ , sfJoinFloats = jbs }) body+ = foldrOL Let (wrapJoinFloats jbs body) bs+ -- Note: Always safe to put the joins on the inside+ -- since the values can't refer to them -getJoinFloatBinds :: SimplEnv -> [CoreBind]-getJoinFloatBinds (SimplEnv {seJoinFloats = jbs})- = fromOL jbs+wrapJoinFloatsX :: SimplFloats -> OutExpr -> (SimplFloats, OutExpr)+-- Wrap the sfJoinFloats of the env around the expression,+-- and take them out of the SimplEnv+wrapJoinFloatsX floats body+ = ( floats { sfJoinFloats = emptyJoinFloats }+ , wrapJoinFloats (sfJoinFloats floats) body ) -isEmptyFloats :: SimplEnv -> Bool-isEmptyFloats env@(SimplEnv {seFloats = Floats bs _})- = isNilOL bs && isEmptyJoinFloats env+wrapJoinFloats :: JoinFloats -> OutExpr -> OutExpr+-- Wrap the sfJoinFloats of the env around the expression,+-- and take them out of the SimplEnv+wrapJoinFloats join_floats body+ = foldrOL Let body join_floats -isEmptyJoinFloats :: SimplEnv -> Bool-isEmptyJoinFloats (SimplEnv {seJoinFloats = jbs})- = isNilOL jbs+getTopFloatBinds :: SimplFloats -> [CoreBind]+getTopFloatBinds (SimplFloats { sfLetFloats = lbs+ , sfJoinFloats = jbs})+ = ASSERT( isNilOL jbs ) -- Can't be any top-level join bindings+ letFloatBinds lbs -mapFloats :: SimplEnv -> ((Id,CoreExpr) -> (Id,CoreExpr)) -> SimplEnv-mapFloats env@SimplEnv { seFloats = Floats fs ff, seJoinFloats = jfs } fun- = env { seFloats = Floats (mapOL app fs) ff- , seJoinFloats = mapOL app jfs }+mapLetFloats :: LetFloats -> ((Id,CoreExpr) -> (Id,CoreExpr)) -> LetFloats+mapLetFloats (LetFloats fs ff) fun+ = LetFloats (mapOL app fs) ff where app (NonRec b e) = case fun (b,e) of (b',e') -> NonRec b' e' app (Rec bs) = Rec (map fun bs)@@ -586,24 +660,15 @@ substId :: SimplEnv -> InId -> SimplSR -- Returns DoneEx only on a non-Var expression substId (SimplEnv { seInScope = in_scope, seIdSubst = ids }) v- = case snd <$> lookupVarEnv ids v of -- Note [Global Ids in the substitution]+ = case lookupVarEnv ids v of -- Note [Global Ids in the substitution] Nothing -> DoneId (refineFromInScope in_scope v) Just (DoneId v) -> DoneId (refineFromInScope in_scope v)- Just (DoneEx (Var v)) -> DoneId (refineFromInScope in_scope v) Just res -> res -- DoneEx non-var, or ContEx -- Get the most up-to-date thing from the in-scope set -- Even though it isn't in the substitution, it may be in -- the in-scope set with better IdInfo -isJoinIdInEnv_maybe :: SimplEnv -> InId -> Maybe JoinArity-isJoinIdInEnv_maybe (SimplEnv { seInScope = inScope, seIdSubst = ids }) v- | not (isLocalId v) = Nothing- | Just (m_ar, _) <- lookupVarEnv ids v = m_ar- | Just v' <- lookupInScope inScope v = isJoinId_maybe v'- | otherwise = WARN( True , ppr v )- isJoinId_maybe v- refineFromInScope :: InScopeSet -> Var -> Var refineFromInScope in_scope v | isLocalId v = case lookupInScope in_scope v of@@ -616,7 +681,7 @@ -- but where we have not yet done its RHS lookupRecBndr (SimplEnv { seInScope = in_scope, seIdSubst = ids }) v = case lookupVarEnv ids v of- Just (_, DoneId v) -> v+ Just (DoneId v) -> v Just _ -> pprPanic "lookupRecBndr" (ppr v) Nothing -> refineFromInScope in_scope v @@ -731,8 +796,7 @@ -- or there's some useful occurrence information -- See the notes with substTyVarBndr for the delSubstEnv new_subst | new_id /= old_id- = extendVarEnv id_subst old_id- (isJoinId_maybe new_id, DoneId new_id)+ = extendVarEnv id_subst old_id (DoneId new_id) | otherwise = delVarEnv id_subst old_id
simplCore/SimplMonad.hs view
@@ -11,7 +11,7 @@ getSimplRules, getFamEnvs, -- Unique supply- MonadUnique(..), newId,+ MonadUnique(..), newId, newJoinId, -- Counting SimplCount, tick, freeTick, checkedTick,@@ -19,8 +19,13 @@ plusSimplCount, isZeroSimplCount ) where +import GhcPrelude++import Var ( Var, isTyVar, mkLocalVar )+import Name ( mkSystemVarName ) import Id ( Id, mkSysLocalOrCoVar )-import Type ( Type )+import IdInfo ( IdDetails(..), vanillaIdInfo, setArityInfo )+import Type ( Type, mkLamTypes ) import FamInstEnv ( FamInstEnv ) import CoreSyn ( RuleEnv(..) ) import UniqSupply@@ -30,6 +35,7 @@ import FastString import MonadUtils import ErrUtils+import Panic (throwGhcExceptionIO, GhcException (..)) import BasicTypes ( IntWithInf, treatZeroAsInf, mkIntWithInf ) import Control.Monad ( when, liftM, ap ) @@ -177,6 +183,19 @@ newId fs ty = do uniq <- getUniqueM return (mkSysLocalOrCoVar fs uniq ty) +newJoinId :: [Var] -> Type -> SimplM Id+newJoinId bndrs body_ty+ = do { uniq <- getUniqueM+ ; let name = mkSystemVarName uniq (fsLit "$j")+ join_id_ty = mkLamTypes bndrs body_ty -- Note [Funky mkLamTypes]+ arity = length (filter (not . isTyVar) bndrs)+ join_arity = length bndrs+ details = JoinId join_arity+ id_info = vanillaIdInfo `setArityInfo` arity+-- `setOccInfo` strongLoopBreaker++ ; return (mkLocalVar details name join_id_ty id_info) }+ {- ************************************************************************ * *@@ -195,16 +214,30 @@ checkedTick :: Tick -> SimplM () -- Try to take a tick, but fail if too many checkedTick t- = SM (\st_env us sc -> if st_max_ticks st_env <= mkIntWithInf (simplCountN sc)- then pprPanic "Simplifier ticks exhausted" (msg sc)- else let sc' = doSimplTick (st_flags st_env) t sc- in sc' `seq` return ((), us, sc'))+ = SM (\st_env us sc ->+ if st_max_ticks st_env <= mkIntWithInf (simplCountN sc)+ then throwGhcExceptionIO $+ PprProgramError "Simplifier ticks exhausted" (msg sc)+ else let sc' = doSimplTick (st_flags st_env) t sc+ in sc' `seq` return ((), us, sc')) where- msg sc = vcat [ text "When trying" <+> ppr t- , text "To increase the limit, use -fsimpl-tick-factor=N (default 100)"- , text "If you need to do this, let GHC HQ know, and what factor you needed"- , pp_details sc- , pprSimplCount sc ]+ msg sc = vcat+ [ text "When trying" <+> ppr t+ , text "To increase the limit, use -fsimpl-tick-factor=N (default 100)."+ , space+ , text "If you need to increase the limit substantially, please file a"+ , text "bug report and indicate the factor you needed."+ , space+ , text "If GHC was unable to complete compilation even"+ <+> text "with a very large factor"+ , text "(a thousand or more), please consult the"+ <+> doubleQuotes (text "Known bugs or infelicities")+ , text "section in the Users Guide before filing a report. There are a"+ , text "few situations unlikely to occur in practical programs for which"+ , text "simplifier non-termination has been judged acceptable."+ , space+ , pp_details sc+ , pprSimplCount sc ] pp_details sc | hasDetailedCounts sc = empty | otherwise = text "To see detailed counts use -ddump-simpl-stats"
simplCore/SimplUtils.hs view
@@ -17,8 +17,8 @@ simplEnvForGHCi, updModeForStableUnfoldings, updModeForRules, -- The continuation type- SimplCont(..), DupFlag(..),- isSimplified,+ SimplCont(..), DupFlag(..), StaticEnv,+ isSimplified, contIsStop, contIsDupable, contResultType, contHoleType, contIsTrivial, contArgs, countArgs,@@ -35,8 +35,10 @@ #include "HsVersions.h" +import GhcPrelude+ import SimplEnv-import CoreMonad ( SimplifierMode(..), Tick(..) )+import CoreMonad ( SimplMode(..), Tick(..) ) import DynFlags import CoreSyn import qualified CoreSubst@@ -53,16 +55,16 @@ import SimplMonad import Type hiding( substTy ) import Coercion hiding( substCo )-import DataCon ( dataConWorkId )-import VarEnv+import DataCon ( dataConWorkId, isNullaryRepDataCon ) import VarSet import BasicTypes import Util+import OrdList ( isNilOL ) import MonadUtils import Outputable import Pair import PrelRules-import Literal+import FastString ( fsLit ) import Control.Monad ( when ) import Data.List ( sortBy )@@ -96,7 +98,7 @@ -} data SimplCont- = Stop -- An empty context, or <hole>+ = Stop -- Stop[e] = e OutType -- Type of the <hole> CallCtxt -- Tells if there is something interesting about -- the context, and hence the inliner@@ -107,46 +109,53 @@ -- Never ValAppCxt (use ApplyToVal instead) -- or CaseCtxt (use Select instead) - | CastIt -- <hole> `cast` co+ | CastIt -- (CastIt co K)[e] = K[ e `cast` co ] OutCoercion -- The coercion simplified -- Invariant: never an identity coercion SimplCont - | ApplyToVal { -- <hole> arg- sc_dup :: DupFlag, -- See Note [DupFlag invariants]- sc_arg :: InExpr, -- The argument,- sc_env :: StaticEnv, -- and its static env- sc_cont :: SimplCont }+ | ApplyToVal -- (ApplyToVal arg K)[e] = K[ e arg ]+ { sc_dup :: DupFlag -- See Note [DupFlag invariants]+ , sc_arg :: InExpr -- The argument,+ , sc_env :: StaticEnv -- see Note [StaticEnv invariant]+ , sc_cont :: SimplCont } - | ApplyToTy { -- <hole> ty- sc_arg_ty :: OutType, -- Argument type- sc_hole_ty :: OutType, -- Type of the function, presumably (forall a. blah)- -- See Note [The hole type in ApplyToTy]- sc_cont :: SimplCont }+ | ApplyToTy -- (ApplyToTy ty K)[e] = K[ e ty ]+ { sc_arg_ty :: OutType -- Argument type+ , sc_hole_ty :: OutType -- Type of the function, presumably (forall a. blah)+ -- See Note [The hole type in ApplyToTy]+ , sc_cont :: SimplCont } - | Select { -- case <hole> of alts- sc_dup :: DupFlag, -- See Note [DupFlag invariants]- sc_bndr :: InId, -- case binder- sc_alts :: [InAlt], -- Alternatives- sc_env :: StaticEnv, -- and their static environment- sc_cont :: SimplCont }+ | Select -- (Select alts K)[e] = K[ case e of alts ]+ { sc_dup :: DupFlag -- See Note [DupFlag invariants]+ , sc_bndr :: InId -- case binder+ , sc_alts :: [InAlt] -- Alternatives+ , sc_env :: StaticEnv -- See Note [StaticEnv invariant]+ , sc_cont :: SimplCont } -- The two strict forms have no DupFlag, because we never duplicate them- | StrictBind -- (\x* \xs. e) <hole>- InId [InBndr] -- let x* = <hole> in e- InExpr StaticEnv -- is a special case- SimplCont+ | StrictBind -- (StrictBind x xs b K)[e] = let x = e in K[\xs.b]+ -- or, equivalently, = K[ (\x xs.b) e ]+ { sc_dup :: DupFlag -- See Note [DupFlag invariants]+ , sc_bndr :: InId+ , sc_bndrs :: [InBndr]+ , sc_body :: InExpr+ , sc_env :: StaticEnv -- See Note [StaticEnv invariant]+ , sc_cont :: SimplCont } - | StrictArg -- f e1 ..en <hole>- ArgInfo -- Specifies f, e1..en, Whether f has rules, etc- -- plus strictness flags for *further* args- CallCtxt -- Whether *this* argument position is interesting- SimplCont+ | StrictArg -- (StrictArg (f e1 ..en) K)[e] = K[ f e1 .. en e ]+ { sc_dup :: DupFlag -- Always Simplified or OkToDup+ , sc_fun :: ArgInfo -- Specifies f, e1..en, Whether f has rules, etc+ -- plus strictness flags for *further* args+ , sc_cci :: CallCtxt -- Whether *this* argument position is interesting+ , sc_cont :: SimplCont } - | TickIt+ | TickIt -- (TickIt t K)[e] = K[ tick t e ] (Tickish Id) -- Tick tickish <hole> SimplCont +type StaticEnv = SimplEnv -- Just the static part is relevant+ data DupFlag = NoDup -- Unsimplified, might be big | Simplified -- Simplified | OkToDup -- Simplified and small@@ -160,7 +169,25 @@ | isSimplified dup = ty | otherwise = substTy env ty -{-+{- Note [StaticEnv invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We pair up an InExpr or InAlts with a StaticEnv, which establishes the+lexical scope for that InExpr. When we simplify that InExpr/InAlts, we+use+ - Its captured StaticEnv+ - Overriding its InScopeSet with the larger one at the+ simplification point.++Why override the InScopeSet? Example:+ (let y = ey in f) ex+By the time we simplify ex, 'y' will be in scope.++However the InScopeSet in the StaticEnv is not irrelevant: it should+include all the free vars of applying the substitution to the InExpr.+Reason: contHoleType uses perhapsSubstTy to apply the substitution to+the expression, and that (rightly) gives ASSERT failures if the InScopeSet+isn't big enough.+ Note [DupFlag invariants] ~~~~~~~~~~~~~~~~~~~~~~~~~ In both (ApplyToVal dup _ env k)@@ -186,11 +213,13 @@ ppr (ApplyToVal { sc_arg = arg, sc_dup = dup, sc_cont = cont }) = (text "ApplyToVal" <+> ppr dup <+> pprParendExpr arg) $$ ppr cont- ppr (StrictBind b _ _ _ cont) = (text "StrictBind" <+> ppr b) $$ ppr cont- ppr (StrictArg ai _ cont) = (text "StrictArg" <+> ppr (ai_fun ai)) $$ ppr cont+ ppr (StrictBind { sc_bndr = b, sc_cont = cont })+ = (text "StrictBind" <+> ppr b) $$ ppr cont+ ppr (StrictArg { sc_fun = ai, sc_cont = cont })+ = (text "StrictArg" <+> ppr (ai_fun ai)) $$ ppr cont ppr (Select { sc_dup = dup, sc_bndr = bndr, sc_alts = alts, sc_env = se, sc_cont = cont }) = (text "Select" <+> ppr dup <+> ppr bndr) $$- ifPprDebug (nest 2 $ vcat [ppr (seTvSubst se), ppr alts]) $$ ppr cont+ whenPprDebug (nest 2 $ vcat [ppr (seTvSubst se), ppr alts]) $$ ppr cont {- Note [The hole type in ApplyToTy]@@ -339,11 +368,16 @@ contIsRhs _ = False -------------------+contIsStop :: SimplCont -> Bool+contIsStop (Stop {}) = True+contIsStop _ = False+ contIsDupable :: SimplCont -> Bool contIsDupable (Stop {}) = True contIsDupable (ApplyToTy { sc_cont = k }) = contIsDupable k contIsDupable (ApplyToVal { sc_dup = OkToDup }) = True -- See Note [DupFlag invariants] contIsDupable (Select { sc_dup = OkToDup }) = True -- ...ditto...+contIsDupable (StrictArg { sc_dup = OkToDup }) = True -- ...ditto... contIsDupable (CastIt _ k) = contIsDupable k contIsDupable _ = False @@ -359,8 +393,8 @@ contResultType :: SimplCont -> OutType contResultType (Stop ty _) = ty contResultType (CastIt _ k) = contResultType k-contResultType (StrictBind _ _ _ _ k) = contResultType k-contResultType (StrictArg _ _ k) = contResultType k+contResultType (StrictBind { sc_cont = k }) = contResultType k+contResultType (StrictArg { sc_cont = k }) = contResultType k contResultType (Select { sc_cont = k }) = contResultType k contResultType (ApplyToTy { sc_cont = k }) = contResultType k contResultType (ApplyToVal { sc_cont = k }) = contResultType k@@ -370,8 +404,9 @@ contHoleType (Stop ty _) = ty contHoleType (TickIt _ k) = contHoleType k contHoleType (CastIt co _) = pFst (coercionKind co)-contHoleType (StrictBind b _ _ se _) = substTy se (idType b)-contHoleType (StrictArg ai _ _) = funArgTy (ai_type ai)+contHoleType (StrictBind { sc_bndr = b, sc_dup = dup, sc_env = se })+ = perhapsSubstTy dup se (idType b)+contHoleType (StrictArg { sc_fun = ai }) = funArgTy (ai_type ai) contHoleType (ApplyToTy { sc_hole_ty = ty }) = ty -- See Note [The hole type in ApplyToTy] contHoleType (ApplyToVal { sc_arg = e, sc_env = se, sc_dup = dup, sc_cont = k }) = mkFunTy (perhapsSubstTy dup se (exprType e))@@ -538,27 +573,43 @@ applies when x is bound to a lambda expression. Hence contIsInteresting looks for case expressions with just a single default case.++Note [No case of case is boring]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we see+ case f x of <alts>++we'd usually treat the context as interesting, to encourage 'f' to+inline. But if case-of-case is off, it's really not so interesting+after all, because we are unlikely to be able to push the case+expression into the branches of any case in f's unfolding. So, to+reduce unnecessary code expansion, we just make the context look boring.+This made a small compile-time perf improvement in perf/compiler/T6048,+and it looks plausible to me. -} -interestingCallContext :: SimplCont -> CallCtxt+interestingCallContext :: SimplEnv -> SimplCont -> CallCtxt -- See Note [Interesting call context]-interestingCallContext cont+interestingCallContext env cont = interesting cont where- interesting (Select {}) = CaseCtxt+ interesting (Select {})+ | sm_case_case (getMode env) = CaseCtxt+ | otherwise = BoringCtxt+ -- See Note [No case of case is boring]+ interesting (ApplyToVal {}) = ValAppCtxt -- Can happen if we have (f Int |> co) y -- If f has an INLINE prag we need to give it some -- motivation to inline. See Note [Cast then apply] -- in CoreUnfold - interesting (StrictArg _ BoringCtxt _) = RhsCtxt- interesting (StrictArg _ cci _) = cci- interesting (StrictBind {}) = BoringCtxt- interesting (Stop _ cci) = cci- interesting (TickIt _ k) = interesting k- interesting (ApplyToTy { sc_cont = k }) = interesting k- interesting (CastIt _ k) = interesting k+ interesting (StrictArg { sc_cci = cci }) = cci+ interesting (StrictBind {}) = BoringCtxt+ interesting (Stop _ cci) = cci+ interesting (TickIt _ k) = interesting k+ interesting (ApplyToTy { sc_cont = k }) = interesting k+ interesting (CastIt _ k) = interesting k -- If this call is the arg of a strict function, the context -- is a bit interesting. If we inline here, we may get useful -- evaluation information to avoid repeated evals: e.g.@@ -600,14 +651,14 @@ where enclosing_fn_has_rules = go call_cont - go (Select {}) = False- go (ApplyToVal {}) = False -- Shouldn't really happen- go (ApplyToTy {}) = False -- Ditto- go (StrictArg _ cci _) = interesting cci- go (StrictBind {}) = False -- ??- go (CastIt _ c) = go c- go (Stop _ cci) = interesting cci- go (TickIt _ c) = go c+ go (Select {}) = False+ go (ApplyToVal {}) = False -- Shouldn't really happen+ go (ApplyToTy {}) = False -- Ditto+ go (StrictArg { sc_cci = cci }) = interesting cci+ go (StrictBind {}) = False -- ??+ go (CastIt _ c) = go c+ go (Stop _ cci) = interesting cci+ go (TickIt _ c) = go c interesting RuleArgCtxt = True interesting _ = False@@ -650,12 +701,10 @@ where -- n is # value args to which the expression is applied go env n (Var v)- | SimplEnv { seIdSubst = ids, seInScope = in_scope } <- env- = case snd <$> lookupVarEnv ids v of- Nothing -> go_var n (refineFromInScope in_scope v)- Just (DoneId v') -> go_var n (refineFromInScope in_scope v')- Just (DoneEx e) -> go (zapSubstEnv env) n e- Just (ContEx tvs cvs ids e) -> go (setSubstEnv env tvs cvs ids) n e+ = case substId env v of+ DoneId v' -> go_var n v'+ DoneEx e _ -> go (zapSubstEnv env) n e+ ContEx tvs cvs ids e -> go (setSubstEnv env tvs cvs ids) n e go _ _ (Lit {}) = ValueArg go _ _ (Type _) = TrivArg@@ -689,11 +738,11 @@ {- ************************************************************************ * *- SimplifierMode+ SimplMode * * ************************************************************************ -The SimplifierMode controls several switches; see its definition in+The SimplMode controls several switches; see its definition in CoreMonad sm_rules :: Bool -- Whether RULES are enabled sm_inline :: Bool -- Whether inlining is enabled@@ -703,19 +752,20 @@ simplEnvForGHCi :: DynFlags -> SimplEnv simplEnvForGHCi dflags- = mkSimplEnv $ SimplMode { sm_names = ["GHCi"]- , sm_phase = InitialPhase- , sm_rules = rules_on+ = mkSimplEnv $ SimplMode { sm_names = ["GHCi"]+ , sm_phase = InitialPhase+ , sm_dflags = dflags+ , sm_rules = rules_on , sm_inline = False , sm_eta_expand = eta_expand_on- , sm_case_case = True }+ , sm_case_case = True } where rules_on = gopt Opt_EnableRewriteRules dflags eta_expand_on = gopt Opt_DoLambdaEtaExpansion dflags -- Do not do any inlining, in case we expose some unboxed -- tuple stuff that confuses the bytecode interpreter -updModeForStableUnfoldings :: Activation -> SimplifierMode -> SimplifierMode+updModeForStableUnfoldings :: Activation -> SimplMode -> SimplMode -- See Note [Simplifying inside stable unfoldings] updModeForStableUnfoldings inline_rule_act current_mode = current_mode { sm_phase = phaseFromActivation inline_rule_act@@ -728,7 +778,7 @@ phaseFromActivation (ActiveAfter _ n) = Phase n phaseFromActivation _ = InitialPhase -updModeForRules :: SimplifierMode -> SimplifierMode+updModeForRules :: SimplMode -> SimplMode -- See Note [Simplifying rules] updModeForRules current_mode = current_mode { sm_phase = InitialPhase@@ -835,7 +885,7 @@ updModeForStableUnfoldings) is this: -------------------------------------------------------------- When simplifying the RHS of an stable unfolding, set the phase+ When simplifying the RHS of a stable unfolding, set the phase to the phase in which the stable unfolding first becomes active ------------------------------------------------------------- @@ -1049,17 +1099,18 @@ the former. -} -preInlineUnconditionally :: DynFlags -> SimplEnv -> TopLevelFlag -> InId -> InExpr -> Bool+preInlineUnconditionally :: SimplEnv -> TopLevelFlag -> InId -> InExpr -> Bool -- Precondition: rhs satisfies the let/app invariant -- See Note [CoreSyn let/app invariant] in CoreSyn -- Reason: we don't want to inline single uses, or discard dead bindings, -- for unlifted, side-effect-ful bindings-preInlineUnconditionally dflags env top_lvl bndr rhs+preInlineUnconditionally env top_lvl bndr rhs+ | not pre_inline_unconditionally = False | not active = False | isStableUnfolding (idUnfolding bndr) = False -- Note [Stable unfoldings and preInlineUnconditionally] | isTopLevel top_lvl && isBottomingId bndr = False -- Note [Top-level bottoming Ids]- | not (gopt Opt_SimplPreInlining dflags) = False | isCoVar bndr = False -- Note [Do not inline CoVars unconditionally]+ | isExitJoinId bndr = False | otherwise = case idOccInfo bndr of IAmDead -> True -- Happens in ((\x.1) v) occ@OneOcc { occ_one_br = True }@@ -1067,7 +1118,8 @@ (occ_int_cxt occ) _ -> False where- mode = getMode env+ pre_inline_unconditionally = gopt Opt_SimplPreInlining (seDynFlags env)+ mode = getMode env active = isActive (sm_phase mode) act -- See Note [pre/postInlineUnconditionally in gentle mode] act = idInlineActivation bndr@@ -1158,18 +1210,16 @@ -} postInlineUnconditionally- :: DynFlags -> SimplEnv -> TopLevelFlag- -> OutId -- The binder (an InId would be fine too)- -- (*not* a CoVar)+ :: SimplEnv -> TopLevelFlag+ -> OutId -- The binder (*not* a CoVar), including its unfolding -> OccInfo -- From the InId -> OutExpr- -> Unfolding -> Bool -- Precondition: rhs satisfies the let/app invariant -- See Note [CoreSyn let/app invariant] in CoreSyn -- Reason: we don't want to inline single uses, or discard dead bindings, -- for unlifted, side-effect-ful bindings-postInlineUnconditionally dflags env top_lvl bndr occ_info rhs unfolding+postInlineUnconditionally env top_lvl bndr occ_info rhs | not active = False | isWeakLoopBreaker occ_info = False -- If it's a loop-breaker of any kind, don't inline -- because it might be referred to "earlier"@@ -1237,7 +1287,9 @@ -- Alas! where- active = isActive (sm_phase (getMode env)) (idInlineActivation bndr)+ unfolding = idUnfolding bndr+ dflags = seDynFlags env+ active = isActive (sm_phase (getMode env)) (idInlineActivation bndr) -- See Note [pre/postInlineUnconditionally in gentle mode] {-@@ -1273,7 +1325,7 @@ Note [Stable unfoldings and postInlineUnconditionally] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Do not do postInlineUnconditionally if the Id has an stable unfolding,+Do not do postInlineUnconditionally if the Id has a stable unfolding, otherwise we lose the unfolding. Example -- f has stable unfolding with rhs (e |> co)@@ -1409,40 +1461,46 @@ ************************************************************************ -} -tryEtaExpandRhs :: SimplEnv -> RecFlag -> OutId -> OutExpr- -> SimplM (Arity, OutExpr)+tryEtaExpandRhs :: SimplMode -> OutId -> OutExpr+ -> SimplM (Arity, Bool, OutExpr) -- See Note [Eta-expanding at let bindings]-tryEtaExpandRhs env is_rec bndr rhs- = do { dflags <- getDynFlags- ; (new_arity, new_rhs) <- try_expand dflags+-- If tryEtaExpandRhs rhs = (n, is_bot, rhs') then+-- (a) rhs' has manifest arity+-- (b) if is_bot is True then rhs' applied to n args is guaranteed bottom+tryEtaExpandRhs mode bndr rhs+ | isJoinId bndr+ = return (manifestArity rhs, False, rhs)+ -- Note [Do not eta-expand join points] + | otherwise+ = do { (new_arity, is_bot, new_rhs) <- try_expand+ ; WARN( new_arity < old_id_arity, (text "Arity decrease:" <+> (ppr bndr <+> ppr old_id_arity <+> ppr old_arity <+> ppr new_arity) $$ ppr new_rhs) ) -- Note [Arity decrease] in Simplify- return (new_arity, new_rhs) }+ return (new_arity, is_bot, new_rhs) } where- try_expand dflags+ try_expand | exprIsTrivial rhs- = return (exprArity rhs, rhs)+ = return (exprArity rhs, False, rhs) - | sm_eta_expand (getMode env) -- Provided eta-expansion is on- , let new_arity1 = findRhsArity dflags bndr rhs old_arity- new_arity2 = idCallArity bndr- new_arity = max new_arity1 new_arity2- , new_arity > old_arity -- And the current manifest arity isn't enough- = if is_rec == Recursive && isJoinId bndr- then WARN(True, text "Can't eta-expand recursive join point:" <+>- ppr bndr)- return (old_arity, rhs)- else do { tick (EtaExpansion bndr)- ; return (new_arity, etaExpand new_arity rhs) }+ | sm_eta_expand mode -- Provided eta-expansion is on+ , new_arity > old_arity -- And the current manifest arity isn't enough+ = do { tick (EtaExpansion bndr)+ ; return (new_arity, is_bot, etaExpand new_arity rhs) }+ | otherwise- = return (old_arity, rhs)+ = return (old_arity, is_bot && new_arity == old_arity, rhs) + dflags = sm_dflags mode old_arity = exprArity rhs -- See Note [Do not expand eta-expand PAPs] old_id_arity = idArity bndr + (new_arity1, is_bot) = findRhsArity dflags bndr rhs old_arity+ new_arity2 = idCallArity bndr+ new_arity = max new_arity1 new_arity2+ {- Note [Eta-expanding at let bindings] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1468,6 +1526,44 @@ as far as the programmer is concerned, it's not applied to two arguments! +Note [Do not eta-expand join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Similarly to CPR (see Note [Don't CPR join points] in WorkWrap), a join point+stands well to gain from its outer binding's eta-expansion, and eta-expanding a+join point is fraught with issues like how to deal with a cast:++ let join $j1 :: IO ()+ $j1 = ...+ $j2 :: Int -> IO ()+ $j2 n = if n > 0 then $j1+ else ...++ =>++ let join $j1 :: IO ()+ $j1 = (\eta -> ...)+ `cast` N:IO :: State# RealWorld -> (# State# RealWorld, ())+ ~ IO ()+ $j2 :: Int -> IO ()+ $j2 n = (\eta -> if n > 0 then $j1+ else ...)+ `cast` N:IO :: State# RealWorld -> (# State# RealWorld, ())+ ~ IO ()++The cast here can't be pushed inside the lambda (since it's not casting to a+function type), so the lambda has to stay, but it can't because it contains a+reference to a join point. In fact, $j2 can't be eta-expanded at all. Rather+than try and detect this situation (and whatever other situations crop up!), we+don't bother; again, any surrounding eta-expansion will improve these join+points anyway, since an outer cast can *always* be pushed inside. By the time+CorePrep comes around, the code is very likely to look more like this:++ let join $j1 :: State# RealWorld -> (# State# RealWorld, ())+ $j1 = (...) eta+ $j2 :: Int -> State# RealWorld -> (# State# RealWorld, ())+ $j2 = if n > 0 then $j1+ else (...) eta+ Note [Do not eta-expand PAPs] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We used to have old_arity = manifestArity rhs, which meant that we@@ -1598,22 +1694,25 @@ which is obviously bogus. -} -abstractFloats :: [OutTyVar] -> SimplEnv -> OutExpr -> SimplM ([OutBind], OutExpr)-abstractFloats main_tvs body_env body+abstractFloats :: DynFlags -> TopLevelFlag -> [OutTyVar] -> SimplFloats+ -> OutExpr -> SimplM ([OutBind], OutExpr)+abstractFloats dflags top_lvl main_tvs floats body = ASSERT( notNull body_floats )+ ASSERT( isNilOL (sfJoinFloats floats) ) do { (subst, float_binds) <- mapAccumLM abstract empty_subst body_floats ; return (float_binds, CoreSubst.substExpr (text "abstract_floats1") subst body) } where+ is_top_lvl = isTopLevel top_lvl main_tv_set = mkVarSet main_tvs- body_floats = getFloatBinds body_env- empty_subst = CoreSubst.mkEmptySubst (seInScope body_env)+ body_floats = letFloatBinds (sfLetFloats floats)+ empty_subst = CoreSubst.mkEmptySubst (sfInScope floats) abstract :: CoreSubst.Subst -> OutBind -> SimplM (CoreSubst.Subst, OutBind) abstract subst (NonRec id rhs)- = do { (poly_id, poly_app) <- mk_poly tvs_here id- ; let poly_rhs = mkLams tvs_here rhs'- subst' = CoreSubst.extendIdSubst subst id poly_app- ; return (subst', (NonRec poly_id poly_rhs)) }+ = do { (poly_id1, poly_app) <- mk_poly1 tvs_here id+ ; let (poly_id2, poly_rhs) = mk_poly2 poly_id1 tvs_here rhs'+ subst' = CoreSubst.extendIdSubst subst id poly_app+ ; return (subst', NonRec poly_id2 poly_rhs) } where rhs' = CoreSubst.substExpr (text "abstract_floats2") subst rhs @@ -1624,11 +1723,13 @@ exprSomeFreeVarsList isTyVar rhs' abstract subst (Rec prs)- = do { (poly_ids, poly_apps) <- mapAndUnzipM (mk_poly tvs_here) ids+ = do { (poly_ids, poly_apps) <- mapAndUnzipM (mk_poly1 tvs_here) ids ; let subst' = CoreSubst.extendSubstList subst (ids `zip` poly_apps)- poly_rhss = [mkLams tvs_here (CoreSubst.substExpr (text "abstract_floats3") subst' rhs)- | rhs <- rhss]- ; return (subst', Rec (poly_ids `zip` poly_rhss)) }+ poly_pairs = [ mk_poly2 poly_id tvs_here rhs'+ | (poly_id, rhs) <- poly_ids `zip` rhss+ , let rhs' = CoreSubst.substExpr (text "abstract_floats")+ subst' rhs ]+ ; return (subst', Rec poly_pairs) } where (ids,rhss) = unzip prs -- For a recursive group, it's a bit of a pain to work out the minimal@@ -1646,7 +1747,8 @@ -- Here, we must abstract 'x' over 'a'. tvs_here = toposortTyVars main_tvs - mk_poly tvs_here var+ mk_poly1 :: [TyVar] -> Id -> SimplM (Id, CoreExpr)+ mk_poly1 tvs_here var = do { uniq <- getUniqueM ; let poly_name = setNameUnique (idName var) uniq -- Keep same name poly_ty = mkInvForAllTys tvs_here (idType var) -- But new type of course@@ -1666,6 +1768,21 @@ -- the occurrences of x' will be just the occurrences originally -- pinned on x. + mk_poly2 :: Id -> [TyVar] -> CoreExpr -> (Id, CoreExpr)+ mk_poly2 poly_id tvs_here rhs+ = (poly_id `setIdUnfolding` unf, poly_rhs)+ where+ poly_rhs = mkLams tvs_here rhs+ unf = mkUnfolding dflags InlineRhs is_top_lvl False poly_rhs++ -- We want the unfolding. Consider+ -- let+ -- x = /\a. let y = ... in Just y+ -- in body+ -- Then we float the y-binding out (via abstractFloats and addPolyBind)+ -- but 'x' may well then be inlined in 'body' in which case we'd like the+ -- opportunity to inline 'y' too.+ {- Note [Abstract over coercions] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1779,8 +1896,12 @@ mkCase tries these things -1. Merge Nested Cases+* Note [Nerge nested cases]+* Note [Eliminate identity case]+* Note [Scrutinee constant folding] +Note [Merge Nested Cases]+~~~~~~~~~~~~~~~~~~~~~~~~~ case e of b { ==> case e of b { p1 -> rhs1 p1 -> rhs1 ... ...@@ -1792,21 +1913,21 @@ _ -> rhsd } - which merges two cases in one case when -- the default alternative of- the outer case scrutises the same variable as the outer case. This- transformation is called Case Merging. It avoids that the same- variable is scrutinised multiple times.--2. Eliminate Identity Case+which merges two cases in one case when -- the default alternative of+the outer case scrutises the same variable as the outer case. This+transformation is called Case Merging. It avoids that the same+variable is scrutinised multiple times. +Note [Eliminate Identity Case]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ case e of ===> e True -> True; False -> False - and similar friends.--3. Scrutinee Constant Folding+and similar friends. +Note [Scrutinee Constant Folding]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ case x op# k# of _ { ===> case x of _ { a1# -> e1 (a1# inv_op# k#) -> e1 a2# -> e2 (a2# inv_op# k#) -> e2@@ -1815,32 +1936,66 @@ where (x op# k#) inv_op# k# == x - And similarly for commuted arguments and for some unary operations.+And similarly for commuted arguments and for some unary operations. - The purpose of this transformation is not only to avoid an arithmetic- operation at runtime but to allow other transformations to apply in cascade.+The purpose of this transformation is not only to avoid an arithmetic+operation at runtime but to allow other transformations to apply in cascade. - Example with the "Merge Nested Cases" optimization (from #12877):+Example with the "Merge Nested Cases" optimization (from #12877): - main = case t of t0- 0## -> ...- DEFAULT -> case t0 `minusWord#` 1## of t1- 0## -> ...- DEFAUT -> case t1 `minusWord#` 1## of t2- 0## -> ...- DEFAULT -> case t2 `minusWord#` 1## of _- 0## -> ...- DEFAULT -> ...+ main = case t of t0+ 0## -> ...+ DEFAULT -> case t0 `minusWord#` 1## of t1+ 0## -> ...+ DEFAUT -> case t1 `minusWord#` 1## of t2+ 0## -> ...+ DEFAULT -> case t2 `minusWord#` 1## of _+ 0## -> ...+ DEFAULT -> ... - becomes:+ becomes: - main = case t of _- 0## -> ...- 1## -> ...- 2## -> ...- 3## -> ...- DEFAULT -> ...+ main = case t of _+ 0## -> ...+ 1## -> ...+ 2## -> ...+ 3## -> ...+ DEFAULT -> ... +There are some wrinkles++* Do not apply caseRules if there is just a single DEFAULT alternative+ case e +# 3# of b { DEFAULT -> rhs }+ If we applied the transformation here we would (stupidly) get+ case a of b' { DEFAULT -> let b = e +# 3# in rhs }+ and now the process may repeat, because that let will really+ be a case.++* The type of the scrutinee might change. E.g.+ case tagToEnum (x :: Int#) of (b::Bool)+ False -> e1+ True -> e2+ ==>+ case x of (b'::Int#)+ DEFAULT -> e1+ 1# -> e2++* The case binder may be used in the right hand sides, so we need+ to make a local binding for it, if it is alive. e.g.+ case e +# 10# of b+ DEFAULT -> blah...b...+ 44# -> blah2...b...+ ===>+ case e of b'+ DEFAULT -> let b = b' +# 10# in blah...b...+ 34# -> let b = 44# in blah2...b...++ Note that in the non-DEFAULT cases we know what to bind 'b' to,+ whereas in the DEFAULT case we must reconstruct the original value.+ But NB: we use b'; we do not duplicate 'e'.++* In dataToTag we might need to make up some fake binders;+ see Note [caseRules for dataToTag] in PrelRules -} mkCase, mkCase1, mkCase2, mkCase3@@ -1941,9 +2096,18 @@ -------------------------------------------------- mkCase2 dflags scrut bndr alts_ty alts- | gopt Opt_CaseFolding dflags- , Just (scrut',f) <- caseRules dflags scrut- = mkCase3 dflags scrut' bndr alts_ty (new_alts f)+ | -- See Note [Scrutinee Constant Folding]+ case alts of -- Not if there is just a DEFAULT alterantive+ [(DEFAULT,_,_)] -> False+ _ -> True+ , gopt Opt_CaseFolding dflags+ , Just (scrut', tx_con, mk_orig) <- caseRules dflags scrut+ = do { bndr' <- newId (fsLit "lwild") (exprType scrut')+ ; alts' <- mapM (tx_alt tx_con mk_orig bndr') alts+ ; mkCase3 dflags scrut' bndr' alts_ty $+ add_default (re_sort alts')+ }+ | otherwise = mkCase3 dflags scrut bndr alts_ty alts where@@ -1959,19 +2123,63 @@ -- 10 -> let y = 20 in e1 -- DEFAULT -> let y = y' + 10 in e2 --- wrap_rhs l rhs- | isDeadBinder bndr = rhs- | otherwise = Let (NonRec bndr l) rhs+ -- This wrapping is done in tx_alt; we use mk_orig, returned by caseRules,+ -- to construct an expression equivalent to the original one, for use+ -- in the DEFAULT case - -- We need to re-sort the alternatives to preserve the #case_invariants#- new_alts f = sortBy cmpAlt (map (mapAlt f) alts)+ tx_alt tx_con mk_orig new_bndr (con, bs, rhs)+ | DataAlt dc <- con', not (isNullaryRepDataCon dc)+ = -- For non-nullary data cons we must invent some fake binders+ -- See Note [caseRules for dataToTag] in PrelRules+ do { us <- getUniquesM+ ; let (ex_tvs, arg_ids) = dataConRepInstPat us dc+ (tyConAppArgs (idType new_bndr))+ ; return (con', ex_tvs ++ arg_ids, rhs') }+ | otherwise+ = return (con', [], rhs')+ where+ con' = tx_con con - mapAlt f alt@(c,bs,e) = case c of- DEFAULT -> (c, bs, wrap_rhs scrut e)- LitAlt l- | isLitValue l -> (LitAlt (mapLitValue dflags f l),- bs, wrap_rhs (Lit l) e)- _ -> pprPanic "Unexpected alternative (mkCase2)" (ppr alt)+ rhs' | isDeadBinder bndr = rhs+ | otherwise = bindNonRec bndr orig_val rhs++ orig_val = case con of+ DEFAULT -> mk_orig new_bndr+ LitAlt l -> Lit l+ DataAlt dc -> mkConApp2 dc (tyConAppArgs (idType bndr)) bs+++ re_sort :: [CoreAlt] -> [CoreAlt] -- Re-sort the alternatives to+ re_sort alts = sortBy cmpAlt alts -- preserve the #case_invariants#++ add_default :: [CoreAlt] -> [CoreAlt]+ -- See Note [Literal cases]+ add_default ((LitAlt {}, bs, rhs) : alts) = (DEFAULT, bs, rhs) : alts+ add_default alts = alts++{- Note [Literal cases]+~~~~~~~~~~~~~~~~~~~~~~~+If we have+ case tagToEnum (a ># b) of+ False -> e1+ True -> e2++then caseRules for TagToEnum will turn it into+ case tagToEnum (a ># b) of+ 0# -> e1+ 1# -> e2++Since the case is exhaustive (all cases are) we can convert it to+ case tagToEnum (a ># b) of+ DEFAULT -> e1+ 1# -> e2++This may generate sligthtly better code (although it should not, since+all cases are exhaustive) and/or optimise better. I'm not certain that+it's necessary, but currenty we do make this change. We do it here,+NOT in the TagToEnum rules (see "Beware" in Note [caseRules for tagToEnum]+in PrelRules)+-} -------------------------------------------------- -- Catch-all
simplCore/Simplify.hs view
@@ -10,3394 +10,3333 @@ #include "HsVersions.h" -import DynFlags-import SimplMonad-import Type hiding ( substTy, substTyVar, extendTvSubst, extendCvSubst )-import SimplEnv-import SimplUtils-import OccurAnal ( occurAnalyseExpr )-import FamInstEnv ( FamInstEnv )-import Literal ( litIsLifted ) --, mkMachInt ) -- temporalily commented out. See #8326-import Id-import MkId ( seqId )-import MkCore ( mkImpossibleExpr, castBottomExpr )-import IdInfo-import Name ( Name, mkSystemVarName, isExternalName, getOccFS )-import Coercion hiding ( substCo, substCoVar )-import OptCoercion ( optCoercion )-import FamInstEnv ( topNormaliseType_maybe )-import DataCon ( DataCon, dataConWorkId, dataConRepStrictness, dataConRepArgTys )---import TyCon ( isEnumerationTyCon ) -- temporalily commented out. See #8326-import CoreMonad ( Tick(..), SimplifierMode(..) )-import CoreSyn-import Demand ( StrictSig(..), dmdTypeDepth, isStrictDmd )-import PprCore ( pprCoreExpr )-import CoreUnfold-import CoreUtils-import CoreArity-import CoreOpt ( pushCoTyArg, pushCoValArg- , joinPointBinding_maybe, joinPointBindings_maybe )---import PrimOp ( tagToEnumKey ) -- temporalily commented out. See #8326-import Rules ( mkRuleInfo, lookupRule, getRules )---import TysPrim ( intPrimTy ) -- temporalily commented out. See #8326-import BasicTypes ( TopLevelFlag(..), isNotTopLevel, isTopLevel,- RecFlag(..) )-import MonadUtils ( foldlM, mapAccumLM, liftIO )-import Maybes ( isJust, fromJust, orElse )---import Unique ( hasKey ) -- temporalily commented out. See #8326-import Control.Monad-import Outputable-import FastString-import Pair-import Util-import ErrUtils-import Module ( moduleName, pprModuleName )--{--The guts of the simplifier is in this module, but the driver loop for-the simplifier is in SimplCore.hs.--------------------------------------------- *** IMPORTANT NOTE ***-------------------------------------------The simplifier used to guarantee that the output had no shadowing, but-it does not do so any more. (Actually, it never did!) The reason is-documented with simplifyArgs.--------------------------------------------- *** IMPORTANT NOTE ***-------------------------------------------Many parts of the simplifier return a bunch of "floats" as well as an-expression. This is wrapped as a datatype SimplUtils.FloatsWith.--All "floats" are let-binds, not case-binds, but some non-rec lets may-be unlifted (with RHS ok-for-speculation).---------------------------------------------- ORGANISATION OF FUNCTIONS-------------------------------------------simplTopBinds- - simplify all top-level binders- - for NonRec, call simplRecOrTopPair- - for Rec, call simplRecBind--- -------------------------------simplExpr (applied lambda) ==> simplNonRecBind-simplExpr (Let (NonRec ...) ..) ==> simplNonRecBind-simplExpr (Let (Rec ...) ..) ==> simplify binders; simplRecBind-- -------------------------------simplRecBind [binders already simplfied]- - use simplRecOrTopPair on each pair in turn--simplRecOrTopPair [binder already simplified]- Used for: recursive bindings (top level and nested)- top-level non-recursive bindings- Returns:- - check for PreInlineUnconditionally- - simplLazyBind--simplNonRecBind- Used for: non-top-level non-recursive bindings- beta reductions (which amount to the same thing)- Because it can deal with strict arts, it takes a- "thing-inside" and returns an expression-- - check for PreInlineUnconditionally- - simplify binder, including its IdInfo- - if strict binding- simplStrictArg- mkAtomicArgs- completeNonRecX- else- simplLazyBind- addFloats--simplNonRecX: [given a *simplified* RHS, but an *unsimplified* binder]- Used for: binding case-binder and constr args in a known-constructor case- - check for PreInLineUnconditionally- - simplify binder- - completeNonRecX-- -------------------------------simplLazyBind: [binder already simplified, RHS not]- Used for: recursive bindings (top level and nested)- top-level non-recursive bindings- non-top-level, but *lazy* non-recursive bindings- [must not be strict or unboxed]- Returns floats + an augmented environment, not an expression- - substituteIdInfo and add result to in-scope- [so that rules are available in rec rhs]- - simplify rhs- - mkAtomicArgs- - float if exposes constructor or PAP- - completeBind---completeNonRecX: [binder and rhs both simplified]- - if the the thing needs case binding (unlifted and not ok-for-spec)- build a Case- else- completeBind- addFloats--completeBind: [given a simplified RHS]- [used for both rec and non-rec bindings, top level and not]- - try PostInlineUnconditionally- - add unfolding [this is the only place we add an unfolding]- - add arity----Right hand sides and arguments-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In many ways we want to treat- (a) the right hand side of a let(rec), and- (b) a function argument-in the same way. But not always! In particular, we would-like to leave these arguments exactly as they are, so they-will match a RULE more easily.-- f (g x, h x)- g (+ x)--It's harder to make the rule match if we ANF-ise the constructor,-or eta-expand the PAP:-- f (let { a = g x; b = h x } in (a,b))- g (\y. + x y)--On the other hand if we see the let-defns-- p = (g x, h x)- q = + x--then we *do* want to ANF-ise and eta-expand, so that p and q-can be safely inlined.--Even floating lets out is a bit dubious. For let RHS's we float lets-out if that exposes a value, so that the value can be inlined more vigorously.-For example-- r = let x = e in (x,x)--Here, if we float the let out we'll expose a nice constructor. We did experiments-that showed this to be a generally good thing. But it was a bad thing to float-lets out unconditionally, because that meant they got allocated more often.--For function arguments, there's less reason to expose a constructor (it won't-get inlined). Just possibly it might make a rule match, but I'm pretty skeptical.-So for the moment we don't float lets out of function arguments either.---Eta expansion-~~~~~~~~~~~~~~-For eta expansion, we want to catch things like-- case e of (a,b) -> \x -> case a of (p,q) -> \y -> r--If the \x was on the RHS of a let, we'd eta expand to bring the two-lambdas together. And in general that's a good thing to do. Perhaps-we should eta expand wherever we find a (value) lambda? Then the eta-expansion at a let RHS can concentrate solely on the PAP case.---Case-of-case and join points-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we perform the case-of-case transform (or otherwise push continuations-inward), we want to treat join points specially. Since they're always-tail-called and we want to maintain this invariant, we can do this (for any-evaluation context E):-- E[join j = e- in case ... of- A -> jump j 1- B -> jump j 2- C -> f 3]-- -->-- join j = E[e]- in case ... of- A -> jump j 1- B -> jump j 2- C -> E[f 3]--As is evident from the example, there are two components to this behavior:-- 1. When entering the RHS of a join point, copy the context inside.- 2. When a join point is invoked, discard the outer context.--Clearly we need to be very careful here to remain consistent---neither part is-optional!--************************************************************************-* *-\subsection{Bindings}-* *-************************************************************************--}--simplTopBinds :: SimplEnv -> [InBind] -> SimplM SimplEnv--simplTopBinds env0 binds0- = do { -- Put all the top-level binders into scope at the start- -- so that if a transformation rule has unexpectedly brought- -- anything into scope, then we don't get a complaint about that.- -- It's rather as if the top-level binders were imported.- -- See note [Glomming] in OccurAnal.- ; env1 <- simplRecBndrs env0 (bindersOfBinds binds0)- ; env2 <- simpl_binds env1 binds0- ; freeTick SimplifierDone- ; return env2 }- where- -- We need to track the zapped top-level binders, because- -- they should have their fragile IdInfo zapped (notably occurrence info)- -- That's why we run down binds and bndrs' simultaneously.- --- simpl_binds :: SimplEnv -> [InBind] -> SimplM SimplEnv- simpl_binds env [] = return env- simpl_binds env (bind:binds) = do { env' <- simpl_bind env bind- ; simpl_binds env' binds }-- simpl_bind env (Rec pairs) = simplRecBind env TopLevel Nothing pairs- simpl_bind env (NonRec b r) = do { (env', b') <- addBndrRules env b (lookupRecBndr env b)- ; simplRecOrTopPair env' TopLevel- NonRecursive Nothing- b b' r }--{--************************************************************************-* *-\subsection{Lazy bindings}-* *-************************************************************************--simplRecBind is used for- * recursive bindings only--}--simplRecBind :: SimplEnv -> TopLevelFlag -> Maybe SimplCont- -> [(InId, InExpr)]- -> SimplM SimplEnv-simplRecBind env0 top_lvl mb_cont pairs0- = do { (env_with_info, triples) <- mapAccumLM add_rules env0 pairs0- ; env1 <- go (zapFloats env_with_info) triples- ; return (env0 `addRecFloats` env1) }- -- addFloats adds the floats from env1,- -- _and_ updates env0 with the in-scope set from env1- where- add_rules :: SimplEnv -> (InBndr,InExpr) -> SimplM (SimplEnv, (InBndr, OutBndr, InExpr))- -- Add the (substituted) rules to the binder- add_rules env (bndr, rhs)- = do { (env', bndr') <- addBndrRules env bndr (lookupRecBndr env bndr)- ; return (env', (bndr, bndr', rhs)) }-- go env [] = return env-- go env ((old_bndr, new_bndr, rhs) : pairs)- = do { env' <- simplRecOrTopPair env top_lvl Recursive mb_cont- old_bndr new_bndr rhs- ; go env' pairs }--{--simplOrTopPair is used for- * recursive bindings (whether top level or not)- * top-level non-recursive bindings--It assumes the binder has already been simplified, but not its IdInfo.--}--simplRecOrTopPair :: SimplEnv- -> TopLevelFlag -> RecFlag -> Maybe SimplCont- -> InId -> OutBndr -> InExpr -- Binder and rhs- -> SimplM SimplEnv -- Returns an env that includes the binding--simplRecOrTopPair env top_lvl is_rec mb_cont old_bndr new_bndr rhs- = do { dflags <- getDynFlags- ; trace_bind dflags $- if preInlineUnconditionally dflags env top_lvl old_bndr rhs- -- Check for unconditional inline- then do tick (PreInlineUnconditionally old_bndr)- return (extendIdSubst env old_bndr (mkContEx env rhs))- else simplBind env top_lvl is_rec mb_cont old_bndr new_bndr rhs env }- where- trace_bind dflags thing_inside- | not (dopt Opt_D_verbose_core2core dflags)- = thing_inside- | otherwise- = pprTrace "SimplBind" (ppr old_bndr) thing_inside- -- trace_bind emits a trace for each top-level binding, which- -- helps to locate the tracing for inlining and rule firing--{--simplBind is used for- * [simplRecOrTopPair] recursive bindings (whether top level or not)- * [simplRecOrTopPair] top-level non-recursive bindings- * [simplNonRecE] non-top-level *lazy* non-recursive bindings--Nota bene:- 1. It assumes that the binder is *already* simplified,- and is in scope, and its IdInfo too, except unfolding-- 2. It assumes that the binder type is lifted.-- 3. It does not check for pre-inline-unconditionally;- that should have been done already.--}--simplBind :: SimplEnv- -> TopLevelFlag -> RecFlag -> Maybe SimplCont- -> InId -> OutId -- Binder, both pre-and post simpl- -- The OutId has IdInfo, except arity, unfolding- -- Ids only, no TyVars- -> InExpr -> SimplEnv -- The RHS and its environment- -> SimplM SimplEnv-simplBind env top_lvl is_rec mb_cont bndr bndr1 rhs rhs_se- | ASSERT( isId bndr1 )- isJoinId bndr1- = ASSERT(isNotTopLevel top_lvl && isJust mb_cont)- simplJoinBind env is_rec (fromJust mb_cont) bndr bndr1 rhs rhs_se- | otherwise- = simplLazyBind env top_lvl is_rec bndr bndr1 rhs rhs_se--simplLazyBind :: SimplEnv- -> TopLevelFlag -> RecFlag- -> InId -> OutId -- Binder, both pre-and post simpl- -- The OutId has IdInfo, except arity, unfolding- -- Ids only, no TyVars- -> InExpr -> SimplEnv -- The RHS and its environment- -> SimplM SimplEnv--- Precondition: rhs obeys the let/app invariant--- NOT used for JoinIds-simplLazyBind env top_lvl is_rec bndr bndr1 rhs rhs_se- = ASSERT( isId bndr )- ASSERT2( not (isJoinId bndr), ppr bndr )- -- pprTrace "simplLazyBind" ((ppr bndr <+> ppr bndr1) $$ ppr rhs $$ ppr (seIdSubst rhs_se)) $- do { let rhs_env = rhs_se `setInScopeAndZapFloats` env- (tvs, body) = case collectTyAndValBinders rhs of- (tvs, [], body)- | surely_not_lam body -> (tvs, body)- _ -> ([], rhs)-- surely_not_lam (Lam {}) = False- surely_not_lam (Tick t e)- | not (tickishFloatable t) = surely_not_lam e- -- eta-reduction could float- surely_not_lam _ = True- -- Do not do the "abstract tyyvar" thing if there's- -- a lambda inside, because it defeats eta-reduction- -- f = /\a. \x. g a x- -- should eta-reduce.--- ; (body_env, tvs') <- simplBinders rhs_env tvs- -- See Note [Floating and type abstraction] in SimplUtils-- -- Simplify the RHS- ; let rhs_cont = mkRhsStop (substTy body_env (exprType body))- ; (body_env0, body0) <- simplExprF body_env body rhs_cont- ; let body1 = wrapJoinFloats body_env0 body0- body_env1 = body_env0 `restoreJoinFloats` body_env-- -- ANF-ise a constructor or PAP rhs- ; (body_env2, body2) <- prepareRhs top_lvl body_env1 bndr1 body1-- ; (env', rhs')- <- if not (doFloatFromRhs top_lvl is_rec False body2 body_env2)- then -- No floating, revert to body1- do { rhs' <- mkLam env tvs' (wrapFloats body_env1 body1) rhs_cont- ; return (env, rhs') }-- else if null tvs then -- Simple floating- do { tick LetFloatFromLet- ; return (addFloats env body_env2, body2) }-- else -- Do type-abstraction first- do { tick LetFloatFromLet- ; (poly_binds, body3) <- abstractFloats tvs' body_env2 body2- ; rhs' <- mkLam env tvs' body3 rhs_cont- ; env' <- foldlM (addPolyBind top_lvl) env poly_binds- ; return (env', rhs') }-- ; completeBind env' top_lvl is_rec Nothing bndr bndr1 rhs' }--simplJoinBind :: SimplEnv- -> RecFlag- -> SimplCont- -> InId -> OutId -- Binder, both pre-and post simpl- -- The OutId has IdInfo, except arity,- -- unfolding- -> InExpr -> SimplEnv -- The RHS and its environment- -> SimplM SimplEnv-simplJoinBind env is_rec cont bndr bndr1 rhs rhs_se- = -- pprTrace "simplLazyBind" ((ppr bndr <+> ppr bndr1) $$- -- ppr rhs $$ ppr (seIdSubst rhs_se)) $- do { let rhs_env = rhs_se `setInScopeAndZapFloats` env-- -- Simplify the RHS- ; rhs' <- simplJoinRhs rhs_env bndr rhs cont- ; completeBind env NotTopLevel is_rec (Just cont) bndr bndr1 rhs' }--{--A specialised variant of simplNonRec used when the RHS is already simplified,-notably in knownCon. It uses case-binding where necessary.--}--simplNonRecX :: SimplEnv- -> InId -- Old binder- -> OutExpr -- Simplified RHS- -> SimplM SimplEnv--- Precondition: rhs satisfies the let/app invariant-simplNonRecX env bndr new_rhs- | isDeadBinder bndr -- Not uncommon; e.g. case (a,b) of c { (p,q) -> p }- = return env -- Here c is dead, and we avoid creating- -- the binding c = (a,b)-- | Coercion co <- new_rhs- = return (extendCvSubst env bndr co)-- | otherwise- = do { (env', bndr') <- simplBinder env bndr- ; completeNonRecX NotTopLevel env' (isStrictId bndr) bndr bndr' new_rhs }- -- simplNonRecX is only used for NotTopLevel things--completeNonRecX :: TopLevelFlag -> SimplEnv- -> Bool- -> InId -- Old binder- -> OutId -- New binder- -> OutExpr -- Simplified RHS- -> SimplM SimplEnv--- Precondition: rhs satisfies the let/app invariant--- See Note [CoreSyn let/app invariant] in CoreSyn--completeNonRecX top_lvl env is_strict old_bndr new_bndr new_rhs- = ASSERT(not (isJoinId new_bndr))- do { (env1, rhs1) <- prepareRhs top_lvl (zapFloats env) new_bndr new_rhs- ; (env2, rhs2) <-- if doFloatFromRhs NotTopLevel NonRecursive is_strict rhs1 env1- then do { tick LetFloatFromLet- ; return (addFloats env env1, rhs1) } -- Add the floats to the main env- else return (env, wrapFloats env1 rhs1) -- Wrap the floats around the RHS- ; completeBind env2 NotTopLevel NonRecursive Nothing- old_bndr new_bndr rhs2 }--{- No, no, no! Do not try preInlineUnconditionally in completeNonRecX- Doing so risks exponential behaviour, because new_rhs has been simplified once already- In the cases described by the folowing commment, postInlineUnconditionally will- catch many of the relevant cases.- -- This happens; for example, the case_bndr during case of- -- known constructor: case (a,b) of x { (p,q) -> ... }- -- Here x isn't mentioned in the RHS, so we don't want to- -- create the (dead) let-binding let x = (a,b) in ...- --- -- Similarly, single occurrences can be inlined vigourously- -- e.g. case (f x, g y) of (a,b) -> ....- -- If a,b occur once we can avoid constructing the let binding for them.-- Furthermore in the case-binding case preInlineUnconditionally risks extra thunks- -- Consider case I# (quotInt# x y) of- -- I# v -> let w = J# v in ...- -- If we gaily inline (quotInt# x y) for v, we end up building an- -- extra thunk:- -- let w = J# (quotInt# x y) in ...- -- because quotInt# can fail.-- | preInlineUnconditionally env NotTopLevel bndr new_rhs- = thing_inside (extendIdSubst env bndr (DoneEx new_rhs))--}-------------------------------------{- Note [Avoiding exponential behaviour]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-One way in which we can get exponential behaviour is if we simplify a-big expression, and the re-simplify it -- and then this happens in a-deeply-nested way. So we must be jolly careful about re-simplifying-an expression. That is why completeNonRecX does not try-preInlineUnconditionally.--Example:- f BIG, where f has a RULE-Then- * We simplify BIG before trying the rule; but the rule does not fire- * We inline f = \x. x True- * So if we did preInlineUnconditionally we'd re-simplify (BIG True)--However, if BIG has /not/ already been simplified, we'd /like/ to-simplify BIG True; maybe good things happen. That is why--* simplLam has- - a case for (isSimplified dup), which goes via simplNonRecX, and- - a case for the un-simplified case, which goes via simplNonRecE--* We go to some efforts to avoid unnecessarily simplifying ApplyToVal,- in at least two places- - In simplCast/addCoerce, where we check for isReflCo- - In rebuildCall we avoid simplifying arguments before we have to- (see Note [Trying rewrite rules])--Note [prepareRhs]-~~~~~~~~~~~~~~~~~~~~-prepareRhs takes a putative RHS, checks whether it's a PAP or-constructor application and, if so, converts it to ANF, so that the-resulting thing can be inlined more easily. Thus- x = (f a, g b)-becomes- t1 = f a- t2 = g b- x = (t1,t2)--We also want to deal well cases like this- v = (f e1 `cast` co) e2-Here we want to make e1,e2 trivial and get- x1 = e1; x2 = e2; v = (f x1 `cast` co) v2-That's what the 'go' loop in prepareRhs does--}--prepareRhs :: TopLevelFlag -> SimplEnv -> OutId -> OutExpr -> SimplM (SimplEnv, OutExpr)--- Adds new floats to the env iff that allows us to return a good RHS--- See Note [prepareRhs]-prepareRhs top_lvl env id (Cast rhs co) -- Note [Float coercions]- | Pair ty1 _ty2 <- coercionKind co -- Do *not* do this if rhs has an unlifted type- , not (isUnliftedType ty1) -- see Note [Float coercions (unlifted)]- = do { (env', rhs') <- makeTrivialWithInfo top_lvl env (getOccFS id) sanitised_info rhs- ; return (env', Cast rhs' co) }- where- sanitised_info = vanillaIdInfo `setStrictnessInfo` strictnessInfo info- `setDemandInfo` demandInfo info- info = idInfo id--prepareRhs top_lvl env0 id rhs0- = do { (_is_exp, env1, rhs1) <- go 0 env0 rhs0- ; return (env1, rhs1) }- where- go n_val_args env (Cast rhs co)- = do { (is_exp, env', rhs') <- go n_val_args env rhs- ; return (is_exp, env', Cast rhs' co) }- go n_val_args env (App fun (Type ty))- = do { (is_exp, env', rhs') <- go n_val_args env fun- ; return (is_exp, env', App rhs' (Type ty)) }- go n_val_args env (App fun arg)- = do { (is_exp, env', fun') <- go (n_val_args+1) env fun- ; case is_exp of- True -> do { (env'', arg') <- makeTrivial top_lvl env' (getOccFS id) arg- ; return (True, env'', App fun' arg') }- False -> return (False, env, App fun arg) }- go n_val_args env (Var fun)- = return (is_exp, env, Var fun)- where- is_exp = isExpandableApp fun n_val_args -- The fun a constructor or PAP- -- See Note [CONLIKE pragma] in BasicTypes- -- The definition of is_exp should match that in- -- OccurAnal.occAnalApp-- go n_val_args env (Tick t rhs)- -- We want to be able to float bindings past this- -- tick. Non-scoping ticks don't care.- | tickishScoped t == NoScope- = do { (is_exp, env', rhs') <- go n_val_args env rhs- ; return (is_exp, env', Tick t rhs') }- -- On the other hand, for scoping ticks we need to be able to- -- copy them on the floats, which in turn is only allowed if- -- we can obtain non-counting ticks.- | not (tickishCounts t) || tickishCanSplit t- = do { (is_exp, env', rhs') <- go n_val_args (zapFloats env) rhs- ; let tickIt (id, expr) = (id, mkTick (mkNoCount t) expr)- floats' = seFloats $ env `addFloats` mapFloats env' tickIt- ; return (is_exp, env' { seFloats = floats' }, Tick t rhs') }-- go _ env other- = return (False, env, other)--{--Note [Float coercions]-~~~~~~~~~~~~~~~~~~~~~~-When we find the binding- x = e `cast` co-we'd like to transform it to- x' = e- x = x `cast` co -- A trivial binding-There's a chance that e will be a constructor application or function, or something-like that, so moving the coercion to the usage site may well cancel the coercions-and lead to further optimisation. Example:-- data family T a :: *- data instance T Int = T Int-- foo :: Int -> Int -> Int- foo m n = ...- where- x = T m- go 0 = 0- go n = case x of { T m -> go (n-m) }- -- This case should optimise--Note [Preserve strictness when floating coercions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In the Note [Float coercions] transformation, keep the strictness info.-Eg- f = e `cast` co -- f has strictness SSL-When we transform to- f' = e -- f' also has strictness SSL- f = f' `cast` co -- f still has strictness SSL--Its not wrong to drop it on the floor, but better to keep it.--Note [Float coercions (unlifted)]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-BUT don't do [Float coercions] if 'e' has an unlifted type.-This *can* happen:-- foo :: Int = (error (# Int,Int #) "urk")- `cast` CoUnsafe (# Int,Int #) Int--If do the makeTrivial thing to the error call, we'll get- foo = case error (# Int,Int #) "urk" of v -> v `cast` ...-But 'v' isn't in scope!--These strange casts can happen as a result of case-of-case- bar = case (case x of { T -> (# 2,3 #); F -> error "urk" }) of- (# p,q #) -> p+q--}--makeTrivialArg :: SimplEnv -> ArgSpec -> SimplM (SimplEnv, ArgSpec)-makeTrivialArg env (ValArg e) = do- { (env', e') <- makeTrivial NotTopLevel env (fsLit "arg") e- ; return (env', ValArg e') }-makeTrivialArg env arg = return (env, arg) -- CastBy, TyArg--makeTrivial :: TopLevelFlag -> SimplEnv- -> FastString -- ^ a "friendly name" to build the new binder from- -> OutExpr -> SimplM (SimplEnv, OutExpr)--- Binds the expression to a variable, if it's not trivial, returning the variable-makeTrivial top_lvl env context expr =- makeTrivialWithInfo top_lvl env context vanillaIdInfo expr--makeTrivialWithInfo :: TopLevelFlag -> SimplEnv- -> FastString- -- ^ a "friendly name" to build the new binder from- -> IdInfo -> OutExpr -> SimplM (SimplEnv, OutExpr)--- Propagate strictness and demand info to the new binder--- Note [Preserve strictness when floating coercions]--- Returned SimplEnv has same substitution as incoming one-makeTrivialWithInfo top_lvl env context info expr- | exprIsTrivial expr -- Already trivial- || not (bindingOk top_lvl expr expr_ty) -- Cannot trivialise- -- See Note [Cannot trivialise]- = return (env, expr)- | otherwise -- See Note [Take care] below- = do { uniq <- getUniqueM- ; let name = mkSystemVarName uniq context- var = mkLocalIdOrCoVarWithInfo name expr_ty info- ; env' <- completeNonRecX top_lvl env False var var expr- ; expr' <- simplVar env' var- ; return (env', expr') }- -- The simplVar is needed because we're constructing a new binding- -- a = rhs- -- And if rhs is of form (rhs1 |> co), then we might get- -- a1 = rhs1- -- a = a1 |> co- -- and now a's RHS is trivial and can be substituted out, and that- -- is what completeNonRecX will do- -- To put it another way, it's as if we'd simplified- -- let var = e in var- where- expr_ty = exprType expr--bindingOk :: TopLevelFlag -> CoreExpr -> Type -> Bool--- True iff we can have a binding of this expression at this level--- Precondition: the type is the type of the expression-bindingOk top_lvl expr expr_ty- | isTopLevel top_lvl = exprIsTopLevelBindable expr expr_ty- | otherwise = True--{--Note [Cannot trivialise]-~~~~~~~~~~~~~~~~~~~~~~~~-Consider tih- f :: Int -> Addr#-- foo :: Bar- foo = Bar (f 3)--Then we can't ANF-ise foo, even though we'd like to, because-we can't make a top-level binding for the Addr# (f 3). And if-so we don't want to turn it into- foo = let x = f 3 in Bar x-because we'll just end up inlining x back, and that makes the-simplifier loop. Better not to ANF-ise it at all.--Literal strings are an exception.-- foo = Ptr "blob"#--We want to turn this into:-- foo1 = "blob"#- foo = Ptr foo1--See Note [CoreSyn top-level string literals] in CoreSyn.--************************************************************************-* *-\subsection{Completing a lazy binding}-* *-************************************************************************--completeBind- * deals only with Ids, not TyVars- * takes an already-simplified binder and RHS- * is used for both recursive and non-recursive bindings- * is used for both top-level and non-top-level bindings--It does the following:- - tries discarding a dead binding- - tries PostInlineUnconditionally- - add unfolding [this is the only place we add an unfolding]- - add arity--It does *not* attempt to do let-to-case. Why? Because it is used for- - top-level bindings (when let-to-case is impossible)- - many situations where the "rhs" is known to be a WHNF- (so let-to-case is inappropriate).--Nor does it do the atomic-argument thing--}--completeBind :: SimplEnv- -> TopLevelFlag -- Flag stuck into unfolding- -> RecFlag -- Recursive binding?- -> Maybe SimplCont -- Required only for join point- -> InId -- Old binder- -> OutId -> OutExpr -- New binder and RHS- -> SimplM SimplEnv--- completeBind may choose to do its work--- * by extending the substitution (e.g. let x = y in ...)--- * or by adding to the floats in the envt------ Precondition: rhs obeys the let/app invariant-completeBind env top_lvl is_rec mb_cont old_bndr new_bndr new_rhs- | isCoVar old_bndr- = case new_rhs of- Coercion co -> return (extendCvSubst env old_bndr co)- _ -> return (addNonRec env new_bndr new_rhs)-- | otherwise- = ASSERT( isId new_bndr )- do { let old_info = idInfo old_bndr- old_unf = unfoldingInfo old_info- occ_info = occInfo old_info-- -- Do eta-expansion on the RHS of the binding- -- See Note [Eta-expanding at let bindings] in SimplUtils- ; (new_arity, final_rhs) <- if isJoinId new_bndr- then return (manifestArity new_rhs, new_rhs)- -- Note [Don't eta-expand join points]- else tryEtaExpandRhs env is_rec- new_bndr new_rhs-- -- Simplify the unfolding- ; new_unfolding <- simplLetUnfolding env top_lvl mb_cont old_bndr- final_rhs old_unf-- ; dflags <- getDynFlags- ; if postInlineUnconditionally dflags env top_lvl new_bndr occ_info- final_rhs new_unfolding-- -- Inline and discard the binding- then do { tick (PostInlineUnconditionally old_bndr)- ; return (extendIdSubst env old_bndr (DoneEx final_rhs)) }- -- Use the substitution to make quite, quite sure that the- -- substitution will happen, since we are going to discard the binding- else- do { let info1 = idInfo new_bndr `setArityInfo` new_arity-- -- Unfolding info: Note [Setting the new unfolding]- info2 = info1 `setUnfoldingInfo` new_unfolding-- -- Demand info: Note [Setting the demand info]- --- -- We also have to nuke demand info if for some reason- -- eta-expansion *reduces* the arity of the binding to less- -- than that of the strictness sig. This can happen: see Note [Arity decrease].- info3 | isEvaldUnfolding new_unfolding- || (case strictnessInfo info2 of- StrictSig dmd_ty -> new_arity < dmdTypeDepth dmd_ty)- = zapDemandInfo info2 `orElse` info2- | otherwise- = info2-- -- Zap call arity info. We have used it by now (via- -- `tryEtaExpandRhs`), and the simplifier can invalidate this- -- information, leading to broken code later (e.g. #13479)- info4 = zapCallArityInfo info3-- final_id = new_bndr `setIdInfo` info4-- ; -- pprTrace "Binding" (ppr final_id <+> ppr new_unfolding) $- return (addNonRec env final_id final_rhs) } }- -- The addNonRec adds it to the in-scope set too---------------------------------addPolyBind :: TopLevelFlag -> SimplEnv -> OutBind -> SimplM SimplEnv--- Add a new binding to the environment, complete with its unfolding--- but *do not* do postInlineUnconditionally, because we have already--- processed some of the scope of the binding--- We still want the unfolding though. Consider--- let--- x = /\a. let y = ... in Just y--- in body--- Then we float the y-binding out (via abstractFloats and addPolyBind)--- but 'x' may well then be inlined in 'body' in which case we'd like the--- opportunity to inline 'y' too.------ INVARIANT: the arity is correct on the incoming binders--addPolyBind top_lvl env (NonRec poly_id rhs)- = do { unfolding <- simplLetUnfolding env top_lvl Nothing poly_id rhs- noUnfolding- -- Assumes that poly_id did not have an INLINE prag- -- which is perhaps wrong. ToDo: think about this- ; let final_id = setIdInfo poly_id $- idInfo poly_id `setUnfoldingInfo` unfolding-- ; return (addNonRec env final_id rhs) }--addPolyBind _ env bind@(Rec _)- = return (extendFloats env bind)- -- Hack: letrecs are more awkward, so we extend "by steam"- -- without adding unfoldings etc. At worst this leads to- -- more simplifier iterations--{- Note [Arity decrease]-~~~~~~~~~~~~~~~~~~~~~~~~-Generally speaking the arity of a binding should not decrease. But it *can*-legitimately happen because of RULES. Eg- f = g Int-where g has arity 2, will have arity 2. But if there's a rewrite rule- g Int --> h-where h has arity 1, then f's arity will decrease. Here's a real-life example,-which is in the output of Specialise:-- Rec {- $dm {Arity 2} = \d.\x. op d- {-# RULES forall d. $dm Int d = $s$dm #-}-- dInt = MkD .... opInt ...- opInt {Arity 1} = $dm dInt-- $s$dm {Arity 0} = \x. op dInt }--Here opInt has arity 1; but when we apply the rule its arity drops to 0.-That's why Specialise goes to a little trouble to pin the right arity-on specialised functions too.--Note [Setting the demand info]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If the unfolding is a value, the demand info may-go pear-shaped, so we nuke it. Example:- let x = (a,b) in- case x of (p,q) -> h p q x-Here x is certainly demanded. But after we've nuked-the case, we'll get just- let x = (a,b) in h a b x-and now x is not demanded (I'm assuming h is lazy)-This really happens. Similarly- let f = \x -> e in ...f..f...-After inlining f at some of its call sites the original binding may-(for example) be no longer strictly demanded.-The solution here is a bit ad hoc...--Note [Don't eta-expand join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--Similarly to CPR (see Note [Don't CPR join points] in WorkWrap), a join point-stands well to gain from its outer binding's eta-expansion, and eta-expanding a-join point is fraught with issues like how to deal with a cast:-- let join $j1 :: IO ()- $j1 = ...- $j2 :: Int -> IO ()- $j2 n = if n > 0 then $j1- else ...-- =>-- let join $j1 :: IO ()- $j1 = (\eta -> ...)- `cast` N:IO :: State# RealWorld -> (# State# RealWorld, ())- ~ IO ()- $j2 :: Int -> IO ()- $j2 n = (\eta -> if n > 0 then $j1- else ...)- `cast` N:IO :: State# RealWorld -> (# State# RealWorld, ())- ~ IO ()--The cast here can't be pushed inside the lambda (since it's not casting to a-function type), so the lambda has to stay, but it can't because it contains a-reference to a join point. In fact, $j2 can't be eta-expanded at all. Rather-than try and detect this situation (and whatever other situations crop up!), we-don't bother; again, any surrounding eta-expansion will improve these join-points anyway, since an outer cast can *always* be pushed inside. By the time-CorePrep comes around, the code is very likely to look more like this:-- let join $j1 :: State# RealWorld -> (# State# RealWorld, ())- $j1 = (...) eta- $j2 :: Int -> State# RealWorld -> (# State# RealWorld, ())- $j2 = if n > 0 then $j1- else (...) eta--************************************************************************-* *-\subsection[Simplify-simplExpr]{The main function: simplExpr}-* *-************************************************************************--The reason for this OutExprStuff stuff is that we want to float *after*-simplifying a RHS, not before. If we do so naively we get quadratic-behaviour as things float out.--To see why it's important to do it after, consider this (real) example:-- let t = f x- in fst t-==>- let t = let a = e1- b = e2- in (a,b)- in fst t-==>- let a = e1- b = e2- t = (a,b)- in- a -- Can't inline a this round, cos it appears twice-==>- e1--Each of the ==> steps is a round of simplification. We'd save a-whole round if we float first. This can cascade. Consider-- let f = g d- in \x -> ...f...-==>- let f = let d1 = ..d.. in \y -> e- in \x -> ...f...-==>- let d1 = ..d..- in \x -> ...(\y ->e)...--Only in this second round can the \y be applied, and it-might do the same again.--}--simplExpr :: SimplEnv -> CoreExpr -> SimplM CoreExpr-simplExpr env (Type ty)- = do { ty' <- simplType env ty -- See Note [Avoiding space leaks in OutType]- ; return (Type ty') }--simplExpr env expr- = simplExprC env expr (mkBoringStop expr_out_ty)- where- expr_out_ty :: OutType- expr_out_ty = substTy env (exprType expr)- -- NB: Since 'expr' is term-valued, not (Type ty), this call- -- to exprType will succeed. exprType fails on (Type ty).--simplExprC :: SimplEnv- -> InExpr -- A term-valued expression, never (Type ty)- -> SimplCont- -> SimplM OutExpr- -- Simplify an expression, given a continuation-simplExprC env expr cont- = -- pprTrace "simplExprC" (ppr expr $$ ppr cont {- $$ ppr (seIdSubst env) -} $$ ppr (seFloats env) ) $- do { (env', expr') <- simplExprF (zapFloats env) expr cont- ; -- pprTrace "simplExprC ret" (ppr expr $$ ppr expr') $- -- pprTrace "simplExprC ret3" (ppr (seInScope env')) $- -- pprTrace "simplExprC ret4" (ppr (seFloats env')) $- return (wrapFloats env' expr') }-----------------------------------------------------simplExprF :: SimplEnv- -> InExpr -- A term-valued expression, never (Type ty)- -> SimplCont- -> SimplM (SimplEnv, OutExpr)--simplExprF env e cont- = -- pprTrace "simplExprF" (vcat--- [ ppr e--- , text "cont =" <+> ppr cont--- , text "inscope =" <+> ppr (seInScope env)--- , text "tvsubst =" <+> ppr (seTvSubst env)--- , text "idsubst =" <+> ppr (seIdSubst env)--- , text "cvsubst =" <+> ppr (seCvSubst env)--- {- , ppr (seFloats env) -}--- ]) $- simplExprF1 env e cont--simplExprF1 :: SimplEnv -> InExpr -> SimplCont- -> SimplM (SimplEnv, OutExpr)--simplExprF1 _ (Type ty) _- = pprPanic "simplExprF: type" (ppr ty)- -- simplExprF does only with term-valued expressions- -- The (Type ty) case is handled separately by simplExpr- -- and by the other callers of simplExprF--simplExprF1 env (Var v) cont = simplIdF env v cont-simplExprF1 env (Lit lit) cont = rebuild env (Lit lit) cont-simplExprF1 env (Tick t expr) cont = simplTick env t expr cont-simplExprF1 env (Cast body co) cont = simplCast env body co cont-simplExprF1 env (Coercion co) cont = simplCoercionF env co cont--simplExprF1 env (App fun arg) cont- = case arg of- Type ty -> do { -- The argument type will (almost) certainly be used- -- in the output program, so just force it now.- -- See Note [Avoiding space leaks in OutType]- arg' <- simplType env ty-- -- But use substTy, not simplType, to avoid forcing- -- the hole type; it will likely not be needed.- -- See Note [The hole type in ApplyToTy]- ; let hole' = substTy env (exprType fun)-- ; simplExprF env fun $- ApplyToTy { sc_arg_ty = arg'- , sc_hole_ty = hole'- , sc_cont = cont } }- _ -> simplExprF env fun $- ApplyToVal { sc_arg = arg, sc_env = env- , sc_dup = NoDup, sc_cont = cont }--simplExprF1 env expr@(Lam {}) cont- = simplLam env zapped_bndrs body cont- -- The main issue here is under-saturated lambdas- -- (\x1. \x2. e) arg1- -- Here x1 might have "occurs-once" occ-info, because occ-info- -- is computed assuming that a group of lambdas is applied- -- all at once. If there are too few args, we must zap the- -- occ-info, UNLESS the remaining binders are one-shot- where- (bndrs, body) = collectBinders expr- zapped_bndrs | need_to_zap = map zap bndrs- | otherwise = bndrs-- need_to_zap = any zappable_bndr (drop n_args bndrs)- n_args = countArgs cont- -- NB: countArgs counts all the args (incl type args)- -- and likewise drop counts all binders (incl type lambdas)-- zappable_bndr b = isId b && not (isOneShotBndr b)- zap b | isTyVar b = b- | otherwise = zapLamIdInfo b--simplExprF1 env (Case scrut bndr _ alts) cont- = simplExprF env scrut (Select { sc_dup = NoDup, sc_bndr = bndr- , sc_alts = alts- , sc_env = env, sc_cont = cont })--simplExprF1 env (Let (Rec pairs) body) cont- = simplRecE env pairs body cont--simplExprF1 env (Let (NonRec bndr rhs) body) cont- | Type ty <- rhs -- First deal with type lets (let a = Type ty in e)- = ASSERT( isTyVar bndr )- do { ty' <- simplType env ty- ; simplExprF (extendTvSubst env bndr ty') body cont }-- | otherwise- = simplNonRecE env bndr (rhs, env) ([], body) cont--{- Note [Avoiding space leaks in OutType]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Since the simplifier is run for multiple iterations, we need to ensure-that any thunks in the output of one simplifier iteration are forced-by the evaluation of the next simplifier iteration. Otherwise we may-retain multiple copies of the Core program and leak a terrible amount-of memory (as in #13426).--The simplifier is naturally strict in the entire "Expr part" of the-input Core program, because any expression may contain binders, which-we must find in order to extend the SimplEnv accordingly. But types-do not contain binders and so it is tempting to write things like-- simplExpr env (Type ty) = return (Type (substTy env ty)) -- Bad!--This is Bad because the result includes a thunk (substTy env ty) which-retains a reference to the whole simplifier environment; and the next-simplifier iteration will not force this thunk either, because the-line above is not strict in ty.--So instead our strategy is for the simplifier to fully evaluate-OutTypes when it emits them into the output Core program, for example-- simplExpr env (Type ty) = do { ty' <- simplType env ty -- Good- ; return (Type ty') }--where the only difference from above is that simplType calls seqType-on the result of substTy.--However, SimplCont can also contain OutTypes and it's not necessarily-a good idea to force types on the way in to SimplCont, because they-may end up not being used and forcing them could be a lot of wasted-work. T5631 is a good example of this.--- For ApplyToTy's sc_arg_ty, we force the type on the way in because- the type will almost certainly appear as a type argument in the- output program.--- For the hole types in Stop and ApplyToTy, we force the type when we- emit it into the output program, after obtaining it from- contResultType. (The hole type in ApplyToTy is only directly used- to form the result type in a new Stop continuation.)--}-------------------------------------- Simplify a join point, adding the context.--- Context goes *inside* the lambdas. IOW, if the join point has arity n, we do:--- \x1 .. xn -> e => \x1 .. xn -> E[e]--- Note that we need the arity of the join point, since e may be a lambda--- (though this is unlikely). See Note [Case-of-case and join points].-simplJoinRhs :: SimplEnv -> InId -> InExpr -> SimplCont- -> SimplM OutExpr-simplJoinRhs env bndr expr cont- | Just arity <- isJoinId_maybe bndr- = do { let (join_bndrs, join_body) = collectNBinders arity expr- ; (env', join_bndrs') <- simplLamBndrs env join_bndrs- ; join_body' <- simplExprC env' join_body cont- ; return $ mkLams join_bndrs' join_body' }-- | otherwise- = pprPanic "simplJoinRhs" (ppr bndr)------------------------------------simplType :: SimplEnv -> InType -> SimplM OutType- -- Kept monadic just so we can do the seqType- -- See Note [Avoiding space leaks in OutType]-simplType env ty- = -- pprTrace "simplType" (ppr ty $$ ppr (seTvSubst env)) $- seqType new_ty `seq` return new_ty- where- new_ty = substTy env ty------------------------------------simplCoercionF :: SimplEnv -> InCoercion -> SimplCont- -> SimplM (SimplEnv, OutExpr)-simplCoercionF env co cont- = do { co' <- simplCoercion env co- ; rebuild env (Coercion co') cont }--simplCoercion :: SimplEnv -> InCoercion -> SimplM OutCoercion-simplCoercion env co- = let opt_co = optCoercion (getTCvSubst env) co- in seqCo opt_co `seq` return opt_co---------------------------------------- | Push a TickIt context outwards past applications and cases, as--- long as this is a non-scoping tick, to let case and application--- optimisations apply.--simplTick :: SimplEnv -> Tickish Id -> InExpr -> SimplCont- -> SimplM (SimplEnv, OutExpr)-simplTick env tickish expr cont- -- A scoped tick turns into a continuation, so that we can spot- -- (scc t (\x . e)) in simplLam and eliminate the scc. If we didn't do- -- it this way, then it would take two passes of the simplifier to- -- reduce ((scc t (\x . e)) e').- -- NB, don't do this with counting ticks, because if the expr is- -- bottom, then rebuildCall will discard the continuation.---- XXX: we cannot do this, because the simplifier assumes that--- the context can be pushed into a case with a single branch. e.g.--- scc<f> case expensive of p -> e--- becomes--- case expensive of p -> scc<f> e------ So I'm disabling this for now. It just means we will do more--- simplifier iterations that necessary in some cases.---- | tickishScoped tickish && not (tickishCounts tickish)--- = simplExprF env expr (TickIt tickish cont)-- -- For unscoped or soft-scoped ticks, we are allowed to float in new- -- cost, so we simply push the continuation inside the tick. This- -- has the effect of moving the tick to the outside of a case or- -- application context, allowing the normal case and application- -- optimisations to fire.- | tickish `tickishScopesLike` SoftScope- = do { (env', expr') <- simplExprF env expr cont- ; return (env', mkTick tickish expr')- }-- -- Push tick inside if the context looks like this will allow us to- -- do a case-of-case - see Note [case-of-scc-of-case]- | Select {} <- cont, Just expr' <- push_tick_inside- = simplExprF env expr' cont-- -- We don't want to move the tick, but we might still want to allow- -- floats to pass through with appropriate wrapping (or not, see- -- wrap_floats below)- --- | not (tickishCounts tickish) || tickishCanSplit tickish- -- = wrap_floats-- | otherwise- = no_floating_past_tick-- where-- -- Try to push tick inside a case, see Note [case-of-scc-of-case].- push_tick_inside =- case expr0 of- Case scrut bndr ty alts- -> Just $ Case (tickScrut scrut) bndr ty (map tickAlt alts)- _other -> Nothing- where (ticks, expr0) = stripTicksTop movable (Tick tickish expr)- movable t = not (tickishCounts t) ||- t `tickishScopesLike` NoScope ||- tickishCanSplit t- tickScrut e = foldr mkTick e ticks- -- Alternatives get annotated with all ticks that scope in some way,- -- but we don't want to count entries.- tickAlt (c,bs,e) = (c,bs, foldr mkTick e ts_scope)- ts_scope = map mkNoCount $- filter (not . (`tickishScopesLike` NoScope)) ticks-- no_floating_past_tick =- do { let (inc,outc) = splitCont cont- ; (env', expr') <- simplExprF (zapFloats env) expr inc- ; let tickish' = simplTickish env tickish- ; (env'', expr'') <- rebuild (zapFloats env')- (wrapFloats env' expr')- (TickIt tickish' outc)- ; return (addFloats env env'', expr'')- }---- Alternative version that wraps outgoing floats with the tick. This--- results in ticks being duplicated, as we don't make any attempt to--- eliminate the tick if we re-inline the binding (because the tick--- semantics allows unrestricted inlining of HNFs), so I'm not doing--- this any more. FloatOut will catch any real opportunities for--- floating.------ wrap_floats =--- do { let (inc,outc) = splitCont cont--- ; (env', expr') <- simplExprF (zapFloats env) expr inc--- ; let tickish' = simplTickish env tickish--- ; let wrap_float (b,rhs) = (zapIdStrictness (setIdArity b 0),--- mkTick (mkNoCount tickish') rhs)--- -- when wrapping a float with mkTick, we better zap the Id's--- -- strictness info and arity, because it might be wrong now.--- ; let env'' = addFloats env (mapFloats env' wrap_float)--- ; rebuild env'' expr' (TickIt tickish' outc)--- }--- simplTickish env tickish- | Breakpoint n ids <- tickish- = Breakpoint n (map (getDoneId . substId env) ids)- | otherwise = tickish-- -- Push type application and coercion inside a tick- splitCont :: SimplCont -> (SimplCont, SimplCont)- splitCont cont@(ApplyToTy { sc_cont = tail }) = (cont { sc_cont = inc }, outc)- where (inc,outc) = splitCont tail- splitCont (CastIt co c) = (CastIt co inc, outc)- where (inc,outc) = splitCont c- splitCont other = (mkBoringStop (contHoleType other), other)-- getDoneId (DoneId id) = id- getDoneId (DoneEx e) = getIdFromTrivialExpr e -- Note [substTickish] in CoreSubst- getDoneId other = pprPanic "getDoneId" (ppr other)---- Note [case-of-scc-of-case]--- It's pretty important to be able to transform case-of-case when--- there's an SCC in the way. For example, the following comes up--- in nofib/real/compress/Encode.hs:------ case scctick<code_string.r1>--- case $wcode_string_r13s wild_XC w1_s137 w2_s138 l_aje--- of _ { (# ww1_s13f, ww2_s13g, ww3_s13h #) ->--- (ww1_s13f, ww2_s13g, ww3_s13h)--- }--- of _ { (ww_s12Y, ww1_s12Z, ww2_s130) ->--- tick<code_string.f1>--- (ww_s12Y,--- ww1_s12Z,--- PTTrees.PT--- @ GHC.Types.Char @ GHC.Types.Int wild2_Xj ww2_s130 r_ajf)--- }------ We really want this case-of-case to fire, because then the 3-tuple--- will go away (indeed, the CPR optimisation is relying on this--- happening). But the scctick is in the way - we need to push it--- inside to expose the case-of-case. So we perform this--- transformation on the inner case:------ scctick c (case e of { p1 -> e1; ...; pn -> en })--- ==>--- case (scctick c e) of { p1 -> scc c e1; ...; pn -> scc c en }------ So we've moved a constant amount of work out of the scc to expose--- the case. We only do this when the continuation is interesting: in--- for now, it has to be another Case (maybe generalise this later).--{--************************************************************************-* *-\subsection{The main rebuilder}-* *-************************************************************************--}--rebuild :: SimplEnv -> OutExpr -> SimplCont -> SimplM (SimplEnv, OutExpr)--- At this point the substitution in the SimplEnv should be irrelevant--- only the in-scope set and floats should matter-rebuild env expr cont- = case cont of- Stop {} -> return (env, expr)- TickIt t cont -> rebuild env (mkTick t expr) cont- CastIt co cont -> rebuild env (mkCast expr co) cont- -- NB: mkCast implements the (Coercion co |> g) optimisation-- Select { sc_bndr = bndr, sc_alts = alts, sc_env = se, sc_cont = cont }- -> rebuildCase (se `setFloats` env) expr bndr alts cont-- StrictArg info _ cont -> rebuildCall env (info `addValArgTo` expr) cont- StrictBind b bs body se cont -> do { env' <- simplNonRecX (se `setFloats` env) b expr- -- expr satisfies let/app since it started life- -- in a call to simplNonRecE- ; simplLam env' bs body cont }-- ApplyToTy { sc_arg_ty = ty, sc_cont = cont}- -> rebuild env (App expr (Type ty)) cont-- ApplyToVal { sc_arg = arg, sc_env = se, sc_dup = dup_flag, sc_cont = cont}- -- See Note [Avoid redundant simplification]- | isSimplified dup_flag- -> rebuild env (App expr arg) cont-- | otherwise- -> do { arg' <- simplExpr (se `setInScopeAndZapFloats` env) arg- ; rebuild env (App expr arg') cont }---{--************************************************************************-* *-\subsection{Lambdas}-* *-************************************************************************--}--simplCast :: SimplEnv -> InExpr -> Coercion -> SimplCont- -> SimplM (SimplEnv, OutExpr)-simplCast env body co0 cont0- = do { co1 <- simplCoercion env co0- ; cont1 <- addCoerce co1 cont0- ; simplExprF env body cont1 }- where- addCoerce :: OutCoercion -> SimplCont -> SimplM SimplCont- addCoerce co1 (CastIt co2 cont)- = addCoerce (mkTransCo co1 co2) cont-- addCoerce co cont@(ApplyToTy { sc_arg_ty = arg_ty, sc_cont = tail })- | Just (arg_ty', co') <- pushCoTyArg co arg_ty- = do { tail' <- addCoerce co' tail- ; return (cont { sc_arg_ty = arg_ty', sc_cont = tail' }) }-- addCoerce co cont@(ApplyToVal { sc_arg = arg, sc_env = arg_se- , sc_dup = dup, sc_cont = tail })- | Just (co1, co2) <- pushCoValArg co- , Pair _ new_ty <- coercionKind co1- , not (isTypeLevPoly new_ty) -- without this check, we get a lev-poly arg- -- See Note [Levity polymorphism invariants] in CoreSyn- -- test: typecheck/should_run/EtaExpandLevPoly- = do { tail' <- addCoerce co2 tail- ; if isReflCo co1- then return (cont { sc_cont = tail' })- -- Avoid simplifying if possible;- -- See Note [Avoiding exponential behaviour]- else do- { (dup', arg_se', arg') <- simplArg env dup arg_se arg- -- When we build the ApplyTo we can't mix the OutCoercion- -- 'co' with the InExpr 'arg', so we simplify- -- to make it all consistent. It's a bit messy.- -- But it isn't a common case.- -- Example of use: Trac #995- ; return (ApplyToVal { sc_arg = mkCast arg' co1- , sc_env = arg_se'- , sc_dup = dup'- , sc_cont = tail' }) } }-- addCoerce co cont- | isReflexiveCo co = return cont- | otherwise = return (CastIt co cont)- -- It's worth checking isReflexiveCo.- -- For example, in the initial form of a worker- -- we may find (coerce T (coerce S (\x.e))) y- -- and we'd like it to simplify to e[y/x] in one round- -- of simplification--simplArg :: SimplEnv -> DupFlag -> StaticEnv -> CoreExpr- -> SimplM (DupFlag, StaticEnv, OutExpr)-simplArg env dup_flag arg_env arg- | isSimplified dup_flag- = return (dup_flag, arg_env, arg)- | otherwise- = do { arg' <- simplExpr (arg_env `setInScopeAndZapFloats` env) arg- ; return (Simplified, zapSubstEnv arg_env, arg') }--{--************************************************************************-* *-\subsection{Lambdas}-* *-************************************************************************--Note [Zap unfolding when beta-reducing]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Lambda-bound variables can have stable unfoldings, such as- $j = \x. \b{Unf=Just x}. e-See Note [Case binders and join points] below; the unfolding for lets-us optimise e better. However when we beta-reduce it we want to-revert to using the actual value, otherwise we can end up in the-stupid situation of- let x = blah in- let b{Unf=Just x} = y- in ...b...-Here it'd be far better to drop the unfolding and use the actual RHS.--}--simplLam :: SimplEnv -> [InId] -> InExpr -> SimplCont- -> SimplM (SimplEnv, OutExpr)--simplLam env [] body cont = simplExprF env body cont-- -- Beta reduction--simplLam env (bndr:bndrs) body (ApplyToTy { sc_arg_ty = arg_ty, sc_cont = cont })- = do { tick (BetaReduction bndr)- ; simplLam (extendTvSubst env bndr arg_ty) bndrs body cont }--simplLam env (bndr:bndrs) body (ApplyToVal { sc_arg = arg, sc_env = arg_se- , sc_cont = cont, sc_dup = dup })- | isSimplified dup -- Don't re-simplify if we've simplified it once- -- See Note [Avoiding exponential behaviour]- = do { tick (BetaReduction bndr)- ; env' <- simplNonRecX env zapped_bndr arg- ; simplLam env' bndrs body cont }-- | otherwise- = do { tick (BetaReduction bndr)- ; simplNonRecE env zapped_bndr (arg, arg_se) (bndrs, body) cont }- where- zapped_bndr -- See Note [Zap unfolding when beta-reducing]- | isId bndr, isStableUnfolding (realIdUnfolding bndr)- = setIdUnfolding bndr NoUnfolding- | otherwise = bndr-- -- discard a non-counting tick on a lambda. This may change the- -- cost attribution slightly (moving the allocation of the- -- lambda elsewhere), but we don't care: optimisation changes- -- cost attribution all the time.-simplLam env bndrs body (TickIt tickish cont)- | not (tickishCounts tickish)- = simplLam env bndrs body cont-- -- Not enough args, so there are real lambdas left to put in the result-simplLam env bndrs body cont- = do { (env', bndrs') <- simplLamBndrs env bndrs- ; body' <- simplExpr env' body- ; new_lam <- mkLam env bndrs' body' cont- ; rebuild env' new_lam cont }--simplLamBndrs :: SimplEnv -> [InBndr] -> SimplM (SimplEnv, [OutBndr])-simplLamBndrs env bndrs = mapAccumLM simplLamBndr env bndrs----------------simplLamBndr :: SimplEnv -> InBndr -> SimplM (SimplEnv, OutBndr)--- Used for lambda binders. These sometimes have unfoldings added by--- the worker/wrapper pass that must be preserved, because they can't--- be reconstructed from context. For example:--- f x = case x of (a,b) -> fw a b x--- fw a b x{=(a,b)} = ...--- The "{=(a,b)}" is an unfolding we can't reconstruct otherwise.-simplLamBndr env bndr- | isId bndr && isFragileUnfolding old_unf -- Special case- = do { (env1, bndr1) <- simplBinder env bndr- ; unf' <- simplUnfolding env1 NotTopLevel Nothing bndr old_unf- ; let bndr2 = bndr1 `setIdUnfolding` unf'- ; return (modifyInScope env1 bndr2, bndr2) }-- | otherwise- = simplBinder env bndr -- Normal case- where- old_unf = idUnfolding bndr---------------------simplNonRecE :: SimplEnv- -> InId -- The binder, always an Id- -- Can be a join point- -> (InExpr, SimplEnv) -- Rhs of binding (or arg of lambda)- -> ([InBndr], InExpr) -- Body of the let/lambda- -- \xs.e- -> SimplCont- -> SimplM (SimplEnv, OutExpr)---- simplNonRecE is used for--- * non-top-level non-recursive lets in expressions--- * beta reduction------ It deals with strict bindings, via the StrictBind continuation,--- which may abort the whole process------ Precondition: rhs satisfies the let/app invariant--- Note [CoreSyn let/app invariant] in CoreSyn------ The "body" of the binding comes as a pair of ([InId],InExpr)--- representing a lambda; so we recurse back to simplLam--- Why? Because of the binder-occ-info-zapping done before--- the call to simplLam in simplExprF (Lam ...)--simplNonRecE env bndr (rhs, rhs_se) (bndrs, body) cont- = ASSERT( isId bndr )- do dflags <- getDynFlags- case () of- _ | preInlineUnconditionally dflags env NotTopLevel bndr rhs- -> do { tick (PreInlineUnconditionally bndr)- ; -- pprTrace "preInlineUncond" (ppr bndr <+> ppr rhs) $- simplLam (extendIdSubst env bndr (mkContEx rhs_se rhs)) bndrs body cont }-- | isStrictId bndr -- Includes coercions- -> simplExprF (rhs_se `setFloats` env) rhs- (StrictBind bndr bndrs body env cont)-- | Just (bndr', rhs') <- joinPointBinding_maybe bndr rhs- -> do { let cont_dup_res_ty = resultTypeOfDupableCont (getMode env)- [bndr'] cont- ; (env1, bndr1) <- simplNonRecJoinBndr env- cont_dup_res_ty bndr'- ; (env2, bndr2) <- addBndrRules env1 bndr' bndr1- ; (env3, cont_dup, cont_nodup)- <- prepareLetCont (zapJoinFloats env2) [bndr'] cont- ; MASSERT2(cont_dup_res_ty `eqType` contResultType cont_dup,- ppr cont_dup_res_ty $$ blankLine $$- ppr cont $$ blankLine $$- ppr cont_dup $$ blankLine $$- ppr cont_nodup)- ; env4 <- simplJoinBind env3 NonRecursive cont_dup bndr' bndr2- rhs' rhs_se- ; (env5, expr) <- simplLam env4 bndrs body cont_dup- ; rebuild (env5 `restoreJoinFloats` env2)- (wrapJoinFloats env5 expr) cont_nodup }-- | otherwise- -> ASSERT( not (isTyVar bndr) )- do { (env1, bndr1) <- simplNonRecBndr env bndr- ; (env2, bndr2) <- addBndrRules env1 bndr bndr1- ; env3 <- simplLazyBind env2 NotTopLevel NonRecursive bndr bndr2 rhs rhs_se- ; simplLam env3 bndrs body cont }---------------------simplRecE :: SimplEnv- -> [(InId, InExpr)]- -> InExpr- -> SimplCont- -> SimplM (SimplEnv, OutExpr)---- simplRecE is used for--- * non-top-level recursive lets in expressions-simplRecE env pairs body cont- | Just pairs' <- joinPointBindings_maybe pairs- = do { let bndrs' = map fst pairs'- cont_dup_res_ty = resultTypeOfDupableCont (getMode env)- bndrs' cont- ; env1 <- simplRecJoinBndrs env cont_dup_res_ty bndrs'- -- NB: bndrs' don't have unfoldings or rules- -- We add them as we go down- ; (env2, cont_dup, cont_nodup) <- prepareLetCont (zapJoinFloats env1)- bndrs' cont- ; MASSERT2(cont_dup_res_ty `eqType` contResultType cont_dup,- ppr cont_dup_res_ty $$ blankLine $$- ppr cont $$ blankLine $$- ppr cont_dup $$ blankLine $$- ppr cont_nodup)- ; env3 <- simplRecBind env2 NotTopLevel (Just cont_dup) pairs'- ; (env4, expr) <- simplExprF env3 body cont_dup- ; rebuild (env4 `restoreJoinFloats` env1)- (wrapJoinFloats env4 expr) cont_nodup }- | otherwise- = do { let bndrs = map fst pairs- ; MASSERT(all (not . isJoinId) bndrs)- ; env1 <- simplRecBndrs env bndrs- -- NB: bndrs' don't have unfoldings or rules- -- We add them as we go down- ; env2 <- simplRecBind env1 NotTopLevel Nothing pairs- ; simplExprF env2 body cont }---{--************************************************************************-* *- Variables-* *-************************************************************************--}--simplVar :: SimplEnv -> InVar -> SimplM OutExpr--- Look up an InVar in the environment-simplVar env var- | isTyVar var = return (Type (substTyVar env var))- | isCoVar var = return (Coercion (substCoVar env var))- | otherwise- = case substId env var of- DoneId var1 -> return (Var var1)- DoneEx e -> return e- ContEx tvs cvs ids e -> simplExpr (setSubstEnv env tvs cvs ids) e--simplIdF :: SimplEnv -> InId -> SimplCont -> SimplM (SimplEnv, OutExpr)-simplIdF env var cont- = case substId env var of- DoneEx e -> simplExprF (zapSubstEnv env) e trimmed_cont- ContEx tvs cvs ids e -> simplExprF (setSubstEnv env tvs cvs ids) e cont- -- Don't trim; haven't already simplified- -- the join, so the cont was never copied- DoneId var1 -> completeCall env var1 trimmed_cont- -- Note [zapSubstEnv]- -- The template is already simplified, so don't re-substitute.- -- This is VITAL. Consider- -- let x = e in- -- let y = \z -> ...x... in- -- \ x -> ...y...- -- We'll clone the inner \x, adding x->x' in the id_subst- -- Then when we inline y, we must *not* replace x by x' in- -- the inlined copy!!- where- trimmed_cont | Just arity <- isJoinIdInEnv_maybe env var- = trim_cont arity cont- | otherwise- = cont-- -- Drop outer context from join point invocation- -- Note [Case-of-case and join points]- trim_cont 0 cont@(Stop {})- = cont- trim_cont 0 cont- = mkBoringStop (contResultType cont)- trim_cont n cont@(ApplyToVal { sc_cont = k })- = cont { sc_cont = trim_cont (n-1) k }- trim_cont n cont@(ApplyToTy { sc_cont = k })- = cont { sc_cont = trim_cont (n-1) k } -- join arity counts types!- trim_cont _ cont- = pprPanic "completeCall" $ ppr var $$ ppr cont-------------------------------------------------------------- Dealing with a call site--completeCall :: SimplEnv -> OutId -> SimplCont -> SimplM (SimplEnv, OutExpr)-completeCall env var cont- = do { ------------- Try inlining ----------------- dflags <- getDynFlags- ; let (lone_variable, arg_infos, call_cont) = contArgs cont- n_val_args = length arg_infos- interesting_cont = interestingCallContext call_cont- unfolding = activeUnfolding env var- maybe_inline = callSiteInline dflags var unfolding- lone_variable arg_infos interesting_cont- ; case maybe_inline of- Just expr -- There is an inlining!- -> do { checkedTick (UnfoldingDone var)- ; dump_inline dflags expr cont- ; simplExprF (zapSubstEnv env) expr cont }-- ; Nothing -> do { rule_base <- getSimplRules- ; let info = mkArgInfo var (getRules rule_base var)- n_val_args call_cont- ; rebuildCall env info cont }- }- where- dump_inline dflags unfolding cont- | not (dopt Opt_D_dump_inlinings dflags) = return ()- | not (dopt Opt_D_verbose_core2core dflags)- = when (isExternalName (idName var)) $- liftIO $ printOutputForUser dflags alwaysQualify $- sep [text "Inlining done:", nest 4 (ppr var)]- | otherwise- = liftIO $ printOutputForUser dflags alwaysQualify $- sep [text "Inlining done: " <> ppr var,- nest 4 (vcat [text "Inlined fn: " <+> nest 2 (ppr unfolding),- text "Cont: " <+> ppr cont])]--rebuildCall :: SimplEnv- -> ArgInfo- -> SimplCont- -> SimplM (SimplEnv, OutExpr)--- We decided not to inline, so--- - simplify the arguments--- - try rewrite rules--- - and rebuild------------ Bottoming applications ---------------rebuildCall env (ArgInfo { ai_fun = fun, ai_args = rev_args, ai_strs = [] }) cont- -- When we run out of strictness args, it means- -- that the call is definitely bottom; see SimplUtils.mkArgInfo- -- Then we want to discard the entire strict continuation. E.g.- -- * case (error "hello") of { ... }- -- * (error "Hello") arg- -- * f (error "Hello") where f is strict- -- etc- -- Then, especially in the first of these cases, we'd like to discard- -- the continuation, leaving just the bottoming expression. But the- -- type might not be right, so we may have to add a coerce.- | not (contIsTrivial cont) -- Only do this if there is a non-trivial- -- continuation to discard, else we do it- -- again and again!- = seqType cont_ty `seq` -- See Note [Avoiding space leaks in OutType]- return (env, castBottomExpr res cont_ty)- where- res = argInfoExpr fun rev_args- cont_ty = contResultType cont------------ Try rewrite RULES ----------------- See Note [Trying rewrite rules]-rebuildCall env info@(ArgInfo { ai_fun = fun, ai_args = rev_args- , ai_rules = Just (nr_wanted, rules) }) cont- | nr_wanted == 0 || no_more_args- , let info' = info { ai_rules = Nothing }- = -- We've accumulated a simplified call in <fun,rev_args>- -- so try rewrite rules; see Note [RULEs apply to simplified arguments]- -- See also Note [Rules for recursive functions]- do { mb_match <- tryRules env rules fun (reverse rev_args) cont- ; case mb_match of- Just (env', rhs, cont') -> simplExprF env' rhs cont'- Nothing -> rebuildCall env info' cont }- where- no_more_args = case cont of- ApplyToTy {} -> False- ApplyToVal {} -> False- _ -> True------------- Simplify applications and casts ---------------rebuildCall env info (CastIt co cont)- = rebuildCall env (addCastTo info co) cont--rebuildCall env info (ApplyToTy { sc_arg_ty = arg_ty, sc_cont = cont })- = rebuildCall env (addTyArgTo info arg_ty) cont--rebuildCall env info@(ArgInfo { ai_encl = encl_rules, ai_type = fun_ty- , ai_strs = str:strs, ai_discs = disc:discs })- (ApplyToVal { sc_arg = arg, sc_env = arg_se- , sc_dup = dup_flag, sc_cont = cont })- | isSimplified dup_flag -- See Note [Avoid redundant simplification]- = rebuildCall env (addValArgTo info' arg) cont-- | str -- Strict argument- = -- pprTrace "Strict Arg" (ppr arg $$ ppr (seIdSubst env) $$ ppr (seInScope env)) $- simplExprF (arg_se `setFloats` env) arg- (StrictArg info' cci_strict cont)- -- Note [Shadowing]-- | otherwise -- Lazy argument- -- DO NOT float anything outside, hence simplExprC- -- There is no benefit (unlike in a let-binding), and we'd- -- have to be very careful about bogus strictness through- -- floating a demanded let.- = do { arg' <- simplExprC (arg_se `setInScopeAndZapFloats` env) arg- (mkLazyArgStop arg_ty cci_lazy)- ; rebuildCall env (addValArgTo info' arg') cont }- where- info' = info { ai_strs = strs, ai_discs = discs }- arg_ty = funArgTy fun_ty-- -- Use this for lazy arguments- cci_lazy | encl_rules = RuleArgCtxt- | disc > 0 = DiscArgCtxt -- Be keener here- | otherwise = BoringCtxt -- Nothing interesting-- -- ..and this for strict arguments- cci_strict | encl_rules = RuleArgCtxt- | disc > 0 = DiscArgCtxt- | otherwise = RhsCtxt- -- Why RhsCtxt? if we see f (g x) (h x), and f is strict, we- -- want to be a bit more eager to inline g, because it may- -- expose an eval (on x perhaps) that can be eliminated or- -- shared. I saw this in nofib 'boyer2', RewriteFuns.onewayunify1- -- It's worth an 18% improvement in allocation for this- -- particular benchmark; 5% on 'mate' and 1.3% on 'multiplier'------------ No further useful info, revert to generic rebuild -------------rebuildCall env (ArgInfo { ai_fun = fun, ai_args = rev_args }) cont- = rebuild env (argInfoExpr fun rev_args) cont--{- Note [Trying rewrite rules]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider an application (f e1 e2 e3) where the e1,e2,e3 are not yet-simplified. We want to simplify enough arguments to allow the rules-to apply, but it's more efficient to avoid simplifying e2,e3 if e1 alone-is sufficient. Example: class ops- (+) dNumInt e2 e3-If we rewrite ((+) dNumInt) to plusInt, we can take advantage of the-latter's strictness when simplifying e2, e3. Moreover, suppose we have- RULE f Int = \x. x True--Then given (f Int e1) we rewrite to- (\x. x True) e1-without simpifying e1. Now we can inline x into its unique call site,-and absorb the True into it all in the same pass. If we simplified-e1 first, we couldn't do that; see Note [Avoiding exponential behaviour].--So we try to apply rules if either- (a) no_more_args: we've run out of argument that the rules can "see"- (b) nr_wanted: none of the rules wants any more arguments---Note [RULES apply to simplified arguments]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's very desirable to try RULES once the arguments have been simplified, because-doing so ensures that rule cascades work in one pass. Consider- {-# RULES g (h x) = k x- f (k x) = x #-}- ...f (g (h x))...-Then we want to rewrite (g (h x)) to (k x) and only then try f's rules. If-we match f's rules against the un-simplified RHS, it won't match. This-makes a particularly big difference when superclass selectors are involved:- op ($p1 ($p2 (df d)))-We want all this to unravel in one sweep.--Note [Avoid redundant simplification]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Because RULES apply to simplified arguments, there's a danger of repeatedly-simplifying already-simplified arguments. An important example is that of- (>>=) d e1 e2-Here e1, e2 are simplified before the rule is applied, but don't really-participate in the rule firing. So we mark them as Simplified to avoid-re-simplifying them.--Note [Shadowing]-~~~~~~~~~~~~~~~~-This part of the simplifier may break the no-shadowing invariant-Consider- f (...(\a -> e)...) (case y of (a,b) -> e')-where f is strict in its second arg-If we simplify the innermost one first we get (...(\a -> e)...)-Simplifying the second arg makes us float the case out, so we end up with- case y of (a,b) -> f (...(\a -> e)...) e'-So the output does not have the no-shadowing invariant. However, there is-no danger of getting name-capture, because when the first arg was simplified-we used an in-scope set that at least mentioned all the variables free in its-static environment, and that is enough.--We can't just do innermost first, or we'd end up with a dual problem:- case x of (a,b) -> f e (...(\a -> e')...)--I spent hours trying to recover the no-shadowing invariant, but I just could-not think of an elegant way to do it. The simplifier is already knee-deep in-continuations. We have to keep the right in-scope set around; AND we have-to get the effect that finding (error "foo") in a strict arg position will-discard the entire application and replace it with (error "foo"). Getting-all this at once is TOO HARD!---************************************************************************-* *- Rewrite rules-* *-************************************************************************--}--tryRules :: SimplEnv -> [CoreRule]- -> Id -> [ArgSpec]- -> SimplCont- -> SimplM (Maybe (SimplEnv, CoreExpr, SimplCont))--tryRules env rules fn args call_cont- | null rules- = return Nothing-{- Disabled until we fix #8326- | fn `hasKey` tagToEnumKey -- See Note [Optimising tagToEnum#]- , [_type_arg, val_arg] <- args- , Select dup bndr ((_,[],rhs1) : rest_alts) se cont <- call_cont- , isDeadBinder bndr- = do { dflags <- getDynFlags- ; let enum_to_tag :: CoreAlt -> CoreAlt- -- Takes K -> e into tagK# -> e- -- where tagK# is the tag of constructor K- enum_to_tag (DataAlt con, [], rhs)- = ASSERT( isEnumerationTyCon (dataConTyCon con) )- (LitAlt tag, [], rhs)- where- tag = mkMachInt dflags (toInteger (dataConTag con - fIRST_TAG))- enum_to_tag alt = pprPanic "tryRules: tagToEnum" (ppr alt)-- new_alts = (DEFAULT, [], rhs1) : map enum_to_tag rest_alts- new_bndr = setIdType bndr intPrimTy- -- The binder is dead, but should have the right type- ; return (Just (val_arg, Select dup new_bndr new_alts se cont)) }--}- | otherwise- = do { dflags <- getDynFlags- ; case lookupRule dflags (getUnfoldingInRuleMatch env) (activeRule env)- fn (argInfoAppArgs args) rules of {- Nothing ->- do { nodump dflags -- This ensures that an empty file is written- ; return Nothing } ; -- No rule matches- Just (rule, rule_rhs) ->- do { checkedTick (RuleFired (ruleName rule))- ; let cont' = pushSimplifiedArgs zapped_env- (drop (ruleArity rule) args)- call_cont- -- (ruleArity rule) says how- -- many args the rule consumed-- occ_anald_rhs = occurAnalyseExpr rule_rhs- -- See Note [Occurrence-analyse after rule firing]- ; dump dflags rule rule_rhs- ; return (Just (zapped_env, occ_anald_rhs, cont')) }}}- -- The occ_anald_rhs and cont' are all Out things- -- hence zapping the environment- where- zapped_env = zapSubstEnv env -- See Note [zapSubstEnv]-- printRuleModule rule =- parens- (maybe (text "BUILTIN") (pprModuleName . moduleName) (ruleModule rule))-- dump dflags rule rule_rhs- | dopt Opt_D_dump_rule_rewrites dflags- = log_rule dflags Opt_D_dump_rule_rewrites "Rule fired" $ vcat- [ text "Rule:" <+> ftext (ruleName rule)- , text "Module:" <+> printRuleModule rule- , text "Before:" <+> hang (ppr fn) 2 (sep (map ppr args))- , text "After: " <+> pprCoreExpr rule_rhs- , text "Cont: " <+> ppr call_cont ]-- | dopt Opt_D_dump_rule_firings dflags- = log_rule dflags Opt_D_dump_rule_firings "Rule fired:" $- ftext (ruleName rule)- <+> printRuleModule rule-- | otherwise- = return ()-- nodump dflags- | dopt Opt_D_dump_rule_rewrites dflags- = liftIO $ dumpSDoc dflags alwaysQualify Opt_D_dump_rule_rewrites "" empty-- | dopt Opt_D_dump_rule_firings dflags- = liftIO $ dumpSDoc dflags alwaysQualify Opt_D_dump_rule_firings "" empty-- | otherwise- = return ()-- log_rule dflags flag hdr details- = liftIO . dumpSDoc dflags alwaysQualify flag "" $- sep [text hdr, nest 4 details]--trySeqRules :: SimplEnv- -> OutExpr -> InExpr -- Scrutinee and RHS- -> SimplCont- -> SimplM (Maybe (SimplEnv, CoreExpr, SimplCont))--- See Note [User-defined RULES for seq]-trySeqRules in_env scrut rhs cont- = do { rule_base <- getSimplRules- ; tryRules in_env (getRules rule_base seqId) seqId out_args rule_cont }- where- no_cast_scrut = drop_casts scrut- scrut_ty = exprType no_cast_scrut- seq_id_ty = idType seqId- rhs_ty = substTy in_env (exprType rhs)- out_args = [ TyArg { as_arg_ty = scrut_ty- , as_hole_ty = seq_id_ty }- , TyArg { as_arg_ty = rhs_ty- , as_hole_ty = piResultTy seq_id_ty scrut_ty }- , ValArg no_cast_scrut]- rule_cont = ApplyToVal { sc_dup = NoDup, sc_arg = rhs- , sc_env = in_env, sc_cont = cont }- -- Lazily evaluated, so we don't do most of this-- drop_casts (Cast e _) = drop_casts e- drop_casts e = e--{- Note [User-defined RULES for seq]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Given- case (scrut |> co) of _ -> rhs-look for rules that match the expression- seq @t1 @t2 scrut-where scrut :: t1- rhs :: t2--If you find a match, rewrite it, and apply to 'rhs'.--Notice that we can simply drop casts on the fly here, which-makes it more likely that a rule will match.--See Note [User-defined RULES for seq] in MkId.--Note [Occurrence-analyse after rule firing]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-After firing a rule, we occurrence-analyse the instantiated RHS before-simplifying it. Usually this doesn't make much difference, but it can-be huge. Here's an example (simplCore/should_compile/T7785)-- map f (map f (map f xs)--= -- Use build/fold form of map, twice- map f (build (\cn. foldr (mapFB c f) n- (build (\cn. foldr (mapFB c f) n xs))))--= -- Apply fold/build rule- map f (build (\cn. (\cn. foldr (mapFB c f) n xs) (mapFB c f) n))--= -- Beta-reduce- -- Alas we have no occurrence-analysed, so we don't know- -- that c is used exactly once- map f (build (\cn. let c1 = mapFB c f in- foldr (mapFB c1 f) n xs))--= -- Use mapFB rule: mapFB (mapFB c f) g = mapFB c (f.g)- -- We can do this because (mapFB c n) is a PAP and hence expandable- map f (build (\cn. let c1 = mapFB c n in- foldr (mapFB c (f.f)) n x))--This is not too bad. But now do the same with the outer map, and-we get another use of mapFB, and t can interact with /both/ remaining-mapFB calls in the above expression. This is stupid because actually-that 'c1' binding is dead. The outer map introduces another c2. If-there is a deep stack of maps we get lots of dead bindings, and lots-of redundant work as we repeatedly simplify the result of firing rules.--The easy thing to do is simply to occurrence analyse the result of-the rule firing. Note that this occ-anals not only the RHS of the-rule, but also the function arguments, which by now are OutExprs.-E.g.- RULE f (g x) = x+1--Call f (g BIG) --> (\x. x+1) BIG--The rule binders are lambda-bound and applied to the OutExpr arguments-(here BIG) which lack all internal occurrence info.--Is this inefficient? Not really: we are about to walk over the result-of the rule firing to simplify it, so occurrence analysis is at most-a constant factor.--Possible improvement: occ-anal the rules when putting them in the-database; and in the simplifier just occ-anal the OutExpr arguments.-But that's more complicated and the rule RHS is usually tiny; so I'm-just doing the simple thing.--Historical note: previously we did occ-anal the rules in Rule.hs,-but failed to occ-anal the OutExpr arguments, which led to the-nasty performance problem described above.---Note [Optimising tagToEnum#]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If we have an enumeration data type:-- data Foo = A | B | C--Then we want to transform-- case tagToEnum# x of ==> case x of- A -> e1 DEFAULT -> e1- B -> e2 1# -> e2- C -> e3 2# -> e3--thereby getting rid of the tagToEnum# altogether. If there was a DEFAULT-alternative we retain it (remember it comes first). If not the case must-be exhaustive, and we reflect that in the transformed version by adding-a DEFAULT. Otherwise Lint complains that the new case is not exhaustive.-See #8317.--Note [Rules for recursive functions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-You might think that we shouldn't apply rules for a loop breaker:-doing so might give rise to an infinite loop, because a RULE is-rather like an extra equation for the function:- RULE: f (g x) y = x+y- Eqn: f a y = a-y--But it's too drastic to disable rules for loop breakers.-Even the foldr/build rule would be disabled, because foldr-is recursive, and hence a loop breaker:- foldr k z (build g) = g k z-So it's up to the programmer: rules can cause divergence---************************************************************************-* *- Rebuilding a case expression-* *-************************************************************************--Note [Case elimination]-~~~~~~~~~~~~~~~~~~~~~~~-The case-elimination transformation discards redundant case expressions.-Start with a simple situation:-- case x# of ===> let y# = x# in e- y# -> e--(when x#, y# are of primitive type, of course). We can't (in general)-do this for algebraic cases, because we might turn bottom into-non-bottom!--The code in SimplUtils.prepareAlts has the effect of generalise this-idea to look for a case where we're scrutinising a variable, and we-know that only the default case can match. For example:-- case x of- 0# -> ...- DEFAULT -> ...(case x of- 0# -> ...- DEFAULT -> ...) ...--Here the inner case is first trimmed to have only one alternative, the-DEFAULT, after which it's an instance of the previous case. This-really only shows up in eliminating error-checking code.--Note that SimplUtils.mkCase combines identical RHSs. So-- case e of ===> case e of DEFAULT -> r- True -> r- False -> r--Now again the case may be elminated by the CaseElim transformation.-This includes things like (==# a# b#)::Bool so that we simplify- case ==# a# b# of { True -> x; False -> x }-to just- x-This particular example shows up in default methods for-comparison operations (e.g. in (>=) for Int.Int32)--Note [Case to let transformation]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If a case over a lifted type has a single alternative, and is being-used as a strict 'let' (all isDeadBinder bndrs), we may want to do-this transformation:-- case e of r ===> let r = e in ...r...- _ -> ...r...--We treat the unlifted and lifted cases separately:--* Unlifted case: 'e' satisfies exprOkForSpeculation- (ok-for-spec is needed to satisfy the let/app invariant).- This turns case a +# b of r -> ...r...- into let r = a +# b in ...r...- and thence .....(a +# b)....-- However, if we have- case indexArray# a i of r -> ...r...- we might like to do the same, and inline the (indexArray# a i).- But indexArray# is not okForSpeculation, so we don't build a let- in rebuildCase (lest it get floated *out*), so the inlining doesn't- happen either. Annoying.--* Lifted case: we need to be sure that the expression is already- evaluated (exprIsHNF). If it's not already evaluated- - we risk losing exceptions, divergence or- user-specified thunk-forcing- - even if 'e' is guaranteed to converge, we don't want to- create a thunk (call by need) instead of evaluating it- right away (call by value)-- However, we can turn the case into a /strict/ let if the 'r' is- used strictly in the body. Then we won't lose divergence; and- we won't build a thunk because the let is strict.- See also Note [Eliminating redundant seqs]-- NB: absentError satisfies exprIsHNF: see Note [aBSENT_ERROR_ID] in MkCore.- We want to turn- case (absentError "foo") of r -> ...MkT r...- into- let r = absentError "foo" in ...MkT r...---Note [Eliminating redundant seqs]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If we have this:- case x of r { _ -> ..r.. }-where 'r' is used strictly in (..r..), the case is effectively a 'seq'-on 'x', but since 'r' is used strictly anyway, we can safely transform to- (...x...)--Note that this can change the error behaviour. For example, we might-transform- case x of { _ -> error "bad" }- --> error "bad"-which is might be puzzling if 'x' currently lambda-bound, but later gets-let-bound to (error "good").--Nevertheless, the paper "A semantics for imprecise exceptions" allows-this transformation. If you want to fix the evaluation order, use-'pseq'. See Trac #8900 for an example where the loss of this-transformation bit us in practice.--See also Note [Empty case alternatives] in CoreSyn.--Just for reference, the original code (added Jan 13) looked like this:- || case_bndr_evald_next rhs-- case_bndr_evald_next :: CoreExpr -> Bool- -- See Note [Case binder next]- case_bndr_evald_next (Var v) = v == case_bndr- case_bndr_evald_next (Cast e _) = case_bndr_evald_next e- case_bndr_evald_next (App e _) = case_bndr_evald_next e- case_bndr_evald_next (Case e _ _ _) = case_bndr_evald_next e- case_bndr_evald_next _ = False--(This came up when fixing Trac #7542. See also Note [Eta reduction of-an eval'd function] in CoreUtils.)---Further notes about case elimination-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider: test :: Integer -> IO ()- test = print--Turns out that this compiles to:- Print.test- = \ eta :: Integer- eta1 :: Void# ->- case PrelNum.< eta PrelNum.zeroInteger of wild { __DEFAULT ->- case hPutStr stdout- (PrelNum.jtos eta ($w[] @ Char))- eta1- of wild1 { (# new_s, a4 #) -> PrelIO.lvl23 new_s }}--Notice the strange '<' which has no effect at all. This is a funny one.-It started like this:--f x y = if x < 0 then jtos x- else if y==0 then "" else jtos x--At a particular call site we have (f v 1). So we inline to get-- if v < 0 then jtos x- else if 1==0 then "" else jtos x--Now simplify the 1==0 conditional:-- if v<0 then jtos v else jtos v--Now common-up the two branches of the case:-- case (v<0) of DEFAULT -> jtos v--Why don't we drop the case? Because it's strict in v. It's technically-wrong to drop even unnecessary evaluations, and in practice they-may be a result of 'seq' so we *definitely* don't want to drop those.-I don't really know how to improve this situation.--}-------------------------------------------------------------- Eliminate the case if possible--rebuildCase, reallyRebuildCase- :: SimplEnv- -> OutExpr -- Scrutinee- -> InId -- Case binder- -> [InAlt] -- Alternatives (inceasing order)- -> SimplCont- -> SimplM (SimplEnv, OutExpr)------------------------------------------------------- 1. Eliminate the case if there's a known constructor-----------------------------------------------------rebuildCase env scrut case_bndr alts cont- | Lit lit <- scrut -- No need for same treatment as constructors- -- because literals are inlined more vigorously- , not (litIsLifted lit)- = do { tick (KnownBranch case_bndr)- ; case findAlt (LitAlt lit) alts of- Nothing -> missingAlt env case_bndr alts cont- Just (_, bs, rhs) -> simple_rhs bs rhs }-- | Just (con, ty_args, other_args) <- exprIsConApp_maybe (getUnfoldingInRuleMatch env) scrut- -- Works when the scrutinee is a variable with a known unfolding- -- as well as when it's an explicit constructor application- = do { tick (KnownBranch case_bndr)- ; case findAlt (DataAlt con) alts of- Nothing -> missingAlt env case_bndr alts cont- Just (DEFAULT, bs, rhs) -> simple_rhs bs rhs- Just (_, bs, rhs) -> knownCon env scrut con ty_args other_args- case_bndr bs rhs cont- }- where- simple_rhs bs rhs = ASSERT( null bs )- do { env' <- simplNonRecX env case_bndr scrut- -- scrut is a constructor application,- -- hence satisfies let/app invariant- ; simplExprF env' rhs cont }-------------------------------------------------------- 2. Eliminate the case if scrutinee is evaluated-----------------------------------------------------rebuildCase env scrut case_bndr alts@[(_, bndrs, rhs)] cont- -- See if we can get rid of the case altogether- -- See Note [Case elimination]- -- mkCase made sure that if all the alternatives are equal,- -- then there is now only one (DEFAULT) rhs-- -- 2a. Dropping the case altogether, if- -- a) it binds nothing (so it's really just a 'seq')- -- b) evaluating the scrutinee has no side effects- | is_plain_seq- , exprOkForSideEffects scrut- -- The entire case is dead, so we can drop it- -- if the scrutinee converges without having imperative- -- side effects or raising a Haskell exception- -- See Note [PrimOp can_fail and has_side_effects] in PrimOp- = simplExprF env rhs cont-- -- 2b. Turn the case into a let, if- -- a) it binds only the case-binder- -- b) unlifted case: the scrutinee is ok-for-speculation- -- lifted case: the scrutinee is in HNF (or will later be demanded)- -- See Note [Case to let transformation]- | all_dead_bndrs- , if isUnliftedType (idType case_bndr)- then exprOkForSpeculation scrut- else exprIsHNF scrut || scrut_is_demanded_var scrut- = do { tick (CaseElim case_bndr)- ; env' <- simplNonRecX env case_bndr scrut- ; simplExprF env' rhs cont }-- -- 2c. Try the seq rules if- -- a) it binds only the case binder- -- b) a rule for seq applies- -- See Note [User-defined RULES for seq] in MkId- | is_plain_seq- = do { mb_rule <- trySeqRules env scrut rhs cont- ; case mb_rule of- Just (env', rule_rhs, cont') -> simplExprF env' rule_rhs cont'- Nothing -> reallyRebuildCase env scrut case_bndr alts cont }- where- all_dead_bndrs = all isDeadBinder bndrs -- bndrs are [InId]- is_plain_seq = all_dead_bndrs && isDeadBinder case_bndr -- Evaluation *only* for effect-- scrut_is_demanded_var :: CoreExpr -> Bool- -- See Note [Eliminating redundant seqs]- scrut_is_demanded_var (Cast s _) = scrut_is_demanded_var s- scrut_is_demanded_var (Var _) = isStrictDmd (idDemandInfo case_bndr)- scrut_is_demanded_var _ = False---rebuildCase env scrut case_bndr alts cont- = reallyRebuildCase env scrut case_bndr alts cont------------------------------------------------------- 3. Catch-all case-----------------------------------------------------reallyRebuildCase env scrut case_bndr alts cont- = do { -- Prepare the continuation;- -- The new subst_env is in place- (env', dup_cont, nodup_cont) <- prepareCaseCont (zapJoinFloats env)- alts cont-- -- Simplify the alternatives- ; (scrut', case_bndr', alts') <- simplAlts env' scrut case_bndr alts dup_cont-- ; dflags <- getDynFlags- ; let alts_ty' = contResultType dup_cont- -- See Note [Avoiding space leaks in OutType]- ; case_expr <- seqType alts_ty' `seq`- mkCase dflags scrut' case_bndr' alts_ty' alts'-- -- Notice that rebuild gets the in-scope set from env', not alt_env- -- (which in any case is only build in simplAlts)- -- The case binder *not* scope over the whole returned case-expression- ; rebuild (env' `restoreJoinFloats` env)- (wrapJoinFloats env' case_expr) nodup_cont }--{--simplCaseBinder checks whether the scrutinee is a variable, v. If so,-try to eliminate uses of v in the RHSs in favour of case_bndr; that-way, there's a chance that v will now only be used once, and hence-inlined.--Historical note: we use to do the "case binder swap" in the Simplifier-so there were additional complications if the scrutinee was a variable.-Now the binder-swap stuff is done in the occurrence analyer; see-OccurAnal Note [Binder swap].--Note [knownCon occ info]-~~~~~~~~~~~~~~~~~~~~~~~~-If the case binder is not dead, then neither are the pattern bound-variables:- case <any> of x { (a,b) ->- case x of { (p,q) -> p } }-Here (a,b) both look dead, but come alive after the inner case is eliminated.-The point is that we bring into the envt a binding- let x = (a,b)-after the outer case, and that makes (a,b) alive. At least we do unless-the case binder is guaranteed dead.--Note [Case alternative occ info]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we are simply reconstructing a case (the common case), we always-zap the occurrence info on the binders in the alternatives. Even-if the case binder is dead, the scrutinee is usually a variable, and *that*-can bring the case-alternative binders back to life.-See Note [Add unfolding for scrutinee]--Note [Improving seq]-~~~~~~~~~~~~~~~~~~~-Consider- type family F :: * -> *- type instance F Int = Int--We'd like to transform- case e of (x :: F Int) { DEFAULT -> rhs }-===>- case e `cast` co of (x'::Int)- I# x# -> let x = x' `cast` sym co- in rhs--so that 'rhs' can take advantage of the form of x'. Notice that Note-[Case of cast] (in OccurAnal) may then apply to the result.--We'd also like to eliminate empty types (Trac #13468). So if-- data Void- type instance F Bool = Void--then we'd like to transform- case (x :: F Bool) of { _ -> error "urk" }-===>- case (x |> co) of (x' :: Void) of {}--Nota Bene: we used to have a built-in rule for 'seq' that dropped-casts, so that- case (x |> co) of { _ -> blah }-dropped the cast; in order to imporove the chances of trySeqRules-firing. But that works in the /opposite/ direction to Note [Improving-seq] so there's a danger of flip/flopping. Better to make trySeqRules-insensitive to the cast, which is now is.--The need for [Improving seq] showed up in Roman's experiments. Example:- foo :: F Int -> Int -> Int- foo t n = t `seq` bar n- where- bar 0 = 0- bar n = bar (n - case t of TI i -> i)-Here we'd like to avoid repeated evaluating t inside the loop, by-taking advantage of the `seq`.--At one point I did transformation in LiberateCase, but it's more-robust here. (Otherwise, there's a danger that we'll simply drop the-'seq' altogether, before LiberateCase gets to see it.)--}--simplAlts :: SimplEnv- -> OutExpr- -> InId -- Case binder- -> [InAlt] -- Non-empty- -> SimplCont- -> SimplM (OutExpr, OutId, [OutAlt]) -- Includes the continuation--- Like simplExpr, this just returns the simplified alternatives;--- it does not return an environment--- The returned alternatives can be empty, none are possible--simplAlts env scrut case_bndr alts cont'- = do { let env0 = zapFloats env-- ; (env1, case_bndr1) <- simplBinder env0 case_bndr- ; let case_bndr2 = case_bndr1 `setIdUnfolding` evaldUnfolding- env2 = modifyInScope env1 case_bndr2- -- See Note [Case binder evaluated-ness]-- ; fam_envs <- getFamEnvs- ; (alt_env', scrut', case_bndr') <- improveSeq fam_envs env2 scrut- case_bndr case_bndr2 alts-- ; (imposs_deflt_cons, in_alts) <- prepareAlts scrut' case_bndr' alts- -- NB: it's possible that the returned in_alts is empty: this is handled- -- by the caller (rebuildCase) in the missingAlt function-- ; alts' <- mapM (simplAlt alt_env' (Just scrut') imposs_deflt_cons case_bndr' cont') in_alts- ; -- pprTrace "simplAlts" (ppr case_bndr $$ ppr alts_ty $$ ppr alts_ty' $$ ppr alts $$ ppr cont') $- return (scrut', case_bndr', alts') }----------------------------------------improveSeq :: (FamInstEnv, FamInstEnv) -> SimplEnv- -> OutExpr -> InId -> OutId -> [InAlt]- -> SimplM (SimplEnv, OutExpr, OutId)--- Note [Improving seq]-improveSeq fam_envs env scrut case_bndr case_bndr1 [(DEFAULT,_,_)]- | Just (co, ty2) <- topNormaliseType_maybe fam_envs (idType case_bndr1)- = do { case_bndr2 <- newId (fsLit "nt") ty2- ; let rhs = DoneEx (Var case_bndr2 `Cast` mkSymCo co)- env2 = extendIdSubst env case_bndr rhs- ; return (env2, scrut `Cast` co, case_bndr2) }--improveSeq _ env scrut _ case_bndr1 _- = return (env, scrut, case_bndr1)----------------------------------------simplAlt :: SimplEnv- -> Maybe OutExpr -- The scrutinee- -> [AltCon] -- These constructors can't be present when- -- matching the DEFAULT alternative- -> OutId -- The case binder- -> SimplCont- -> InAlt- -> SimplM OutAlt--simplAlt env _ imposs_deflt_cons case_bndr' cont' (DEFAULT, bndrs, rhs)- = ASSERT( null bndrs )- do { let env' = addBinderUnfolding env case_bndr'- (mkOtherCon imposs_deflt_cons)- -- Record the constructors that the case-binder *can't* be.- ; rhs' <- simplExprC env' rhs cont'- ; return (DEFAULT, [], rhs') }--simplAlt env scrut' _ case_bndr' cont' (LitAlt lit, bndrs, rhs)- = ASSERT( null bndrs )- do { env' <- addAltUnfoldings env scrut' case_bndr' (Lit lit)- ; rhs' <- simplExprC env' rhs cont'- ; return (LitAlt lit, [], rhs') }--simplAlt env scrut' _ case_bndr' cont' (DataAlt con, vs, rhs)- = do { -- Deal with the pattern-bound variables- -- Mark the ones that are in ! positions in the- -- data constructor as certainly-evaluated.- -- NB: simplLamBinders preserves this eval info- ; let vs_with_evals = add_evals (dataConRepStrictness con)- ; (env', vs') <- simplLamBndrs env vs_with_evals-- -- Bind the case-binder to (con args)- ; let inst_tys' = tyConAppArgs (idType case_bndr')- con_app :: OutExpr- con_app = mkConApp2 con inst_tys' vs'-- ; env'' <- addAltUnfoldings env' scrut' case_bndr' con_app- ; rhs' <- simplExprC env'' rhs cont'- ; return (DataAlt con, vs', rhs') }- where- -- add_evals records the evaluated-ness of the bound variables of- -- a case pattern. This is *important*. Consider- -- data T = T !Int !Int- --- -- case x of { T a b -> T (a+1) b }- --- -- We really must record that b is already evaluated so that we don't- -- go and re-evaluate it when constructing the result.- -- See Note [Data-con worker strictness] in MkId.hs- add_evals the_strs- = go vs the_strs- where- go [] [] = []- go (v:vs') strs | isTyVar v = v : go vs' strs- go (v:vs') (str:strs) = zap str v : go vs' strs- go _ _ = pprPanic "cat_evals"- (ppr con $$- ppr vs $$- ppr_with_length the_strs $$- ppr_with_length (dataConRepArgTys con) $$- ppr_with_length (dataConRepStrictness con))- where- ppr_with_length list- = ppr list <+> parens (text "length =" <+> ppr (length list))- -- NB: If this panic triggers, note that- -- NoStrictnessMark doesn't print!-- zap str v = setCaseBndrEvald str $ -- Add eval'dness info- zapIdOccInfo v -- And kill occ info;- -- see Note [Case alternative occ info]--addAltUnfoldings :: SimplEnv -> Maybe OutExpr -> OutId -> OutExpr -> SimplM SimplEnv-addAltUnfoldings env scrut case_bndr con_app- = do { dflags <- getDynFlags- ; let con_app_unf = mkSimpleUnfolding dflags con_app- env1 = addBinderUnfolding env case_bndr con_app_unf-- -- See Note [Add unfolding for scrutinee]- env2 = case scrut of- Just (Var v) -> addBinderUnfolding env1 v con_app_unf- Just (Cast (Var v) co) -> addBinderUnfolding env1 v $- mkSimpleUnfolding dflags (Cast con_app (mkSymCo co))- _ -> env1-- ; traceSmpl "addAltUnf" (vcat [ppr case_bndr <+> ppr scrut, ppr con_app])- ; return env2 }--addBinderUnfolding :: SimplEnv -> Id -> Unfolding -> SimplEnv-addBinderUnfolding env bndr unf- | debugIsOn, Just tmpl <- maybeUnfoldingTemplate unf- = WARN( not (eqType (idType bndr) (exprType tmpl)),- ppr bndr $$ ppr (idType bndr) $$ ppr tmpl $$ ppr (exprType tmpl) )- modifyInScope env (bndr `setIdUnfolding` unf)-- | otherwise- = modifyInScope env (bndr `setIdUnfolding` unf)--zapBndrOccInfo :: Bool -> Id -> Id--- Consider case e of b { (a,b) -> ... }--- Then if we bind b to (a,b) in "...", and b is not dead,--- then we must zap the deadness info on a,b-zapBndrOccInfo keep_occ_info pat_id- | keep_occ_info = pat_id- | otherwise = zapIdOccInfo pat_id--{- Note [Case binder evaluated-ness]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We pin on a (OtherCon []) unfolding to the case-binder of a Case,-even though it'll be over-ridden in every case alternative with a more-informative unfolding. Why? Because suppose a later, less clever, pass-simply replaces all occurrences of the case binder with the binder itself;-then Lint may complain about the let/app invariant. Example- case e of b { DEFAULT -> let v = reallyUnsafePtrEq# b y in ....- ; K -> blah }--The let/app invariant requires that y is evaluated in the call to-reallyUnsafePtrEq#, which it is. But we still want that to be true if we-propagate binders to occurrences.--This showed up in Trac #13027.--Note [Add unfolding for scrutinee]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In general it's unlikely that a variable scrutinee will appear-in the case alternatives case x of { ...x unlikely to appear... }-because the binder-swap in OccAnal has got rid of all such occcurrences-See Note [Binder swap] in OccAnal.--BUT it is still VERY IMPORTANT to add a suitable unfolding for a-variable scrutinee, in simplAlt. Here's why- case x of y- (a,b) -> case b of c- I# v -> ...(f y)...-There is no occurrence of 'b' in the (...(f y)...). But y gets-the unfolding (a,b), and *that* mentions b. If f has a RULE- RULE f (p, I# q) = ...-we want that rule to match, so we must extend the in-scope env with a-suitable unfolding for 'y'. It's *essential* for rule matching; but-it's also good for case-elimintation -- suppose that 'f' was inlined-and did multi-level case analysis, then we'd solve it in one-simplifier sweep instead of two.--Exactly the same issue arises in SpecConstr;-see Note [Add scrutinee to ValueEnv too] in SpecConstr--HOWEVER, given- case x of y { Just a -> r1; Nothing -> r2 }-we do not want to add the unfolding x -> y to 'x', which might seem cool,-since 'y' itself has different unfoldings in r1 and r2. Reason: if we-did that, we'd have to zap y's deadness info and that is a very useful-piece of information.--So instead we add the unfolding x -> Just a, and x -> Nothing in the-respective RHSs.---************************************************************************-* *-\subsection{Known constructor}-* *-************************************************************************--We are a bit careful with occurrence info. Here's an example-- (\x* -> case x of (a*, b) -> f a) (h v, e)--where the * means "occurs once". This effectively becomes- case (h v, e) of (a*, b) -> f a)-and then- let a* = h v; b = e in f a-and then- f (h v)--All this should happen in one sweep.--}--knownCon :: SimplEnv- -> OutExpr -- The scrutinee- -> DataCon -> [OutType] -> [OutExpr] -- The scrutinee (in pieces)- -> InId -> [InBndr] -> InExpr -- The alternative- -> SimplCont- -> SimplM (SimplEnv, OutExpr)--knownCon env scrut dc dc_ty_args dc_args bndr bs rhs cont- = do { env' <- bind_args env bs dc_args- ; env'' <- bind_case_bndr env'- ; simplExprF env'' rhs cont }- where- zap_occ = zapBndrOccInfo (isDeadBinder bndr) -- bndr is an InId-- -- Ugh!- bind_args env' [] _ = return env'-- bind_args env' (b:bs') (Type ty : args)- = ASSERT( isTyVar b )- bind_args (extendTvSubst env' b ty) bs' args-- bind_args env' (b:bs') (Coercion co : args)- = ASSERT( isCoVar b )- bind_args (extendCvSubst env' b co) bs' args-- bind_args env' (b:bs') (arg : args)- = ASSERT( isId b )- do { let b' = zap_occ b- -- Note that the binder might be "dead", because it doesn't- -- occur in the RHS; and simplNonRecX may therefore discard- -- it via postInlineUnconditionally.- -- Nevertheless we must keep it if the case-binder is alive,- -- because it may be used in the con_app. See Note [knownCon occ info]- ; env'' <- simplNonRecX env' b' arg -- arg satisfies let/app invariant- ; bind_args env'' bs' args }-- bind_args _ _ _ =- pprPanic "bind_args" $ ppr dc $$ ppr bs $$ ppr dc_args $$- text "scrut:" <+> ppr scrut-- -- It's useful to bind bndr to scrut, rather than to a fresh- -- binding x = Con arg1 .. argn- -- because very often the scrut is a variable, so we avoid- -- creating, and then subsequently eliminating, a let-binding- -- BUT, if scrut is a not a variable, we must be careful- -- about duplicating the arg redexes; in that case, make- -- a new con-app from the args- bind_case_bndr env- | isDeadBinder bndr = return env- | exprIsTrivial scrut = return (extendIdSubst env bndr (DoneEx scrut))- | otherwise = do { dc_args <- mapM (simplVar env) bs- -- dc_ty_args are aready OutTypes,- -- but bs are InBndrs- ; let con_app = Var (dataConWorkId dc)- `mkTyApps` dc_ty_args- `mkApps` dc_args- ; simplNonRecX env bndr con_app }----------------------missingAlt :: SimplEnv -> Id -> [InAlt] -> SimplCont -> SimplM (SimplEnv, OutExpr)- -- This isn't strictly an error, although it is unusual.- -- It's possible that the simplifier might "see" that- -- an inner case has no accessible alternatives before- -- it "sees" that the entire branch of an outer case is- -- inaccessible. So we simply put an error case here instead.-missingAlt env case_bndr _ cont- = WARN( True, text "missingAlt" <+> ppr case_bndr )- -- See Note [Avoiding space leaks in OutType]- let cont_ty = contResultType cont- in seqType cont_ty `seq` return (env, mkImpossibleExpr cont_ty)--{--************************************************************************-* *-\subsection{Duplicating continuations}-* *-************************************************************************--}--prepareCaseCont :: SimplEnv- -> [InAlt] -> SimplCont- -> SimplM (SimplEnv,- SimplCont, -- Dupable part- SimplCont) -- Non-dupable part--- We are considering--- K[case _ of { p1 -> r1; ...; pn -> rn }]--- where K is some enclosing continuation for the case--- Goal: split K into two pieces Kdup,Knodup so that--- a) Kdup can be duplicated--- b) Knodup[Kdup[e]] = K[e]--- The idea is that we'll transform thus:--- Knodup[ (case _ of { p1 -> Kdup[r1]; ...; pn -> Kdup[rn] }------ We may also return some extra value bindings in SimplEnv (that scope over--- the entire continuation) as well as some join points (thus must *not* float--- past the continuation!).--- Hence, the full story is this:--- K[case _ of { p1 -> r1; ...; pn -> rn }] ==>--- F_v[Knodup[F_j[ (case _ of { p1 -> Kdup[r1]; ...; pn -> Kdup[rn] }) ]]]--- Here F_v represents some values that got floated out and F_j represents some--- join points that got floated out.------ When case-of-case is off, just make the entire continuation non-dupable--prepareCaseCont env alts cont- | not (sm_case_case (getMode env))- = return (env, mkBoringStop (contHoleType cont), cont)- | not (altsWouldDup alts)- = return (env, cont, mkBoringStop (contResultType cont))- | otherwise- = mkDupableCont env cont--prepareLetCont :: SimplEnv- -> [InBndr] -> SimplCont- -> SimplM (SimplEnv,- SimplCont, -- Dupable part- SimplCont) -- Non-dupable part---- Similar to prepareCaseCont, only for--- K[let { j1 = r1; ...; jn -> rn } in _]--- If the js are join points, this will turn into--- Knodup[join { j1 = Kdup[r1]; ...; jn = Kdup[rn] } in Kdup[_]].------ When case-of-case is off and it's a join binding, just make the entire--- continuation non-dupable. This is necessary because otherwise--- case (join j = ... in case e of { A -> jump j 1; ... }) of { B -> ... }--- becomes--- join j = case ... of { B -> ... } in--- case (case e of { A -> jump j 1; ... }) of { B -> ... },--- and the reference to j is invalid.--prepareLetCont env bndrs cont- | not (isJoinId (head bndrs))- = return (env, cont, mkBoringStop (contResultType cont))- | not (sm_case_case (getMode env))- = return (env, mkBoringStop (contHoleType cont), cont)- | otherwise- = mkDupableCont env cont---- Predict the result type of the dupable cont returned by prepareLetCont (= the--- hole type of the non-dupable part). Ugly, but sadly necessary so that we can--- know what the new type of a recursive join point will be before we start--- simplifying it.-resultTypeOfDupableCont :: SimplifierMode- -> [InBndr]- -> SimplCont- -> OutType -- INVARIANT: Result type of dupable cont- -- returned by prepareLetCont--- IMPORTANT: This must be kept in sync with mkDupableCont!-resultTypeOfDupableCont mode bndrs cont- | not (any isJoinId bndrs) = contResultType cont- | not (sm_case_case mode) = contHoleType cont- | otherwise = go cont- where- go cont | contIsDupable cont = contResultType cont- go (Stop {}) = panic "typeOfDupableCont" -- Handled by previous eqn- go (CastIt _ cont) = go cont- go cont@(TickIt {}) = contHoleType cont- go cont@(StrictBind {}) = contHoleType cont- go (StrictArg _ _ cont) = go cont- go cont@(ApplyToTy {}) = go (sc_cont cont)- go cont@(ApplyToVal {}) = go (sc_cont cont)- go (Select { sc_alts = alts, sc_cont = cont })- | not (sm_case_case mode) = contHoleType cont- | not (altsWouldDup alts) = contResultType cont- | otherwise = go cont--altsWouldDup :: [InAlt] -> Bool -- True iff strictly > 1 non-bottom alternative-altsWouldDup [] = False -- See Note [Bottom alternatives]-altsWouldDup [_] = False-altsWouldDup (alt:alts)- | is_bot_alt alt = altsWouldDup alts- | otherwise = not (all is_bot_alt alts)- where- is_bot_alt (_,_,rhs) = exprIsBottom rhs--{--Note [Bottom alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~-When we have- case (case x of { A -> error .. ; B -> e; C -> error ..)- of alts-then we can just duplicate those alts because the A and C cases-will disappear immediately. This is more direct than creating-join points and inlining them away. See Trac #4930.--}--mkDupableCont :: SimplEnv -> SimplCont- -> SimplM (SimplEnv, SimplCont, SimplCont)--mkDupableCont env cont- | contIsDupable cont- = return (env, cont, mkBoringStop (contResultType cont))--mkDupableCont _ (Stop {}) = panic "mkDupableCont" -- Handled by previous eqn--mkDupableCont env (CastIt ty cont)- = do { (env', dup, nodup) <- mkDupableCont env cont- ; return (env', CastIt ty dup, nodup) }---- Duplicating ticks for now, not sure if this is good or not-mkDupableCont env cont@(TickIt{})- = return (env, mkBoringStop (contHoleType cont), cont)--mkDupableCont env cont@(StrictBind {})- = return (env, mkBoringStop (contHoleType cont), cont)- -- See Note [Duplicating StrictBind]--mkDupableCont env (StrictArg info cci cont)- -- See Note [Duplicating StrictArg]- = do { (env', dup, nodup) <- mkDupableCont env cont- ; (env'', args') <- mapAccumLM makeTrivialArg env' (ai_args info)- ; return (env'', StrictArg (info { ai_args = args' }) cci dup, nodup) }--mkDupableCont env cont@(ApplyToTy { sc_cont = tail })- = do { (env', dup_cont, nodup_cont) <- mkDupableCont env tail- ; return (env', cont { sc_cont = dup_cont }, nodup_cont ) }--mkDupableCont env (ApplyToVal { sc_arg = arg, sc_dup = dup, sc_env = se, sc_cont = cont })- = -- e.g. [...hole...] (...arg...)- -- ==>- -- let a = ...arg...- -- in [...hole...] a- do { (env', dup_cont, nodup_cont) <- mkDupableCont env cont- ; (_, se', arg') <- simplArg env' dup se arg- ; (env'', arg'') <- makeTrivial NotTopLevel env' (fsLit "karg") arg'- ; let app_cont = ApplyToVal { sc_arg = arg'', sc_env = se'- , sc_dup = OkToDup, sc_cont = dup_cont }- ; return (env'', app_cont, nodup_cont) }--mkDupableCont env (Select { sc_bndr = case_bndr, sc_alts = alts- , sc_env = se, sc_cont = cont })- = -- e.g. (case [...hole...] of { pi -> ei })- -- ===>- -- let ji = \xij -> ei- -- in case [...hole...] of { pi -> ji xij }- do { tick (CaseOfCase case_bndr)- ; (env', dup_cont, nodup_cont) <- prepareCaseCont env alts cont- -- NB: We call prepareCaseCont here. If there is only one- -- alternative, then dup_cont may be big, but that's ok- -- because we push it into the single alternative, and then- -- use mkDupableAlt to turn that simplified alternative into- -- a join point if it's too big to duplicate.- -- And this is important: see Note [Fusing case continuations]-- ; let alt_env = se `setInScopeAndZapFloats` env'-- ; (alt_env', case_bndr') <- simplBinder alt_env case_bndr- ; alts' <- mapM (simplAlt alt_env' Nothing [] case_bndr' dup_cont) alts- -- Safe to say that there are no handled-cons for the DEFAULT case- -- NB: simplBinder does not zap deadness occ-info, so- -- a dead case_bndr' will still advertise its deadness- -- This is really important because in- -- case e of b { (# p,q #) -> ... }- -- b is always dead, and indeed we are not allowed to bind b to (# p,q #),- -- which might happen if e was an explicit unboxed pair and b wasn't marked dead.- -- In the new alts we build, we have the new case binder, so it must retain- -- its deadness.- -- NB: we don't use alt_env further; it has the substEnv for- -- the alternatives, and we don't want that-- ; (env'', alts'') <- mkDupableAlts env' case_bndr' alts'- ; return (env'', -- Note [Duplicated env]- Select { sc_dup = OkToDup- , sc_bndr = case_bndr', sc_alts = alts''- , sc_env = zapSubstEnv env''- , sc_cont = mkBoringStop (contHoleType nodup_cont) },- nodup_cont) }---mkDupableAlts :: SimplEnv -> OutId -> [InAlt]- -> SimplM (SimplEnv, [InAlt])--- Absorbs the continuation into the new alternatives--mkDupableAlts env case_bndr' the_alts- = go env the_alts- where- go env0 [] = return (env0, [])- go env0 (alt:alts)- = do { (env1, alt') <- mkDupableAlt env0 case_bndr' alt- ; (env2, alts') <- go env1 alts- ; return (env2, alt' : alts' ) }--mkDupableAlt :: SimplEnv -> OutId -> (AltCon, [CoreBndr], CoreExpr)- -> SimplM (SimplEnv, (AltCon, [CoreBndr], CoreExpr))-mkDupableAlt env case_bndr (con, bndrs', rhs') = do- dflags <- getDynFlags- if exprIsDupable dflags rhs' -- Note [Small alternative rhs]- then return (env, (con, bndrs', rhs'))- else- do { let rhs_ty' = exprType rhs'- scrut_ty = idType case_bndr- case_bndr_w_unf- = case con of- DEFAULT -> case_bndr- DataAlt dc -> setIdUnfolding case_bndr unf- where- -- See Note [Case binders and join points]- unf = mkInlineUnfolding rhs- rhs = mkConApp2 dc (tyConAppArgs scrut_ty) bndrs'-- LitAlt {} -> WARN( True, text "mkDupableAlt"- <+> ppr case_bndr <+> ppr con )- case_bndr- -- The case binder is alive but trivial, so why has- -- it not been substituted away?-- final_bndrs'- | isDeadBinder case_bndr = filter abstract_over bndrs'- | otherwise = bndrs' ++ [case_bndr_w_unf]-- abstract_over bndr- | isTyVar bndr = True -- Abstract over all type variables just in case- | otherwise = not (isDeadBinder bndr)- -- The deadness info on the new Ids is preserved by simplBinders- final_args -- Note [Join point abstraction]- = varsToCoreExprs final_bndrs'-- ; join_bndr <- newId (fsLit "$j") (mkLamTypes final_bndrs' rhs_ty')- -- Note [Funky mkLamTypes]-- ; let -- We make the lambdas into one-shot-lambdas. The- -- join point is sure to be applied at most once, and doing so- -- prevents the body of the join point being floated out by- -- the full laziness pass- really_final_bndrs = map one_shot final_bndrs'- one_shot v | isId v = setOneShotLambda v- | otherwise = v- join_rhs = mkLams really_final_bndrs rhs'- arity = length (filter (not . isTyVar) final_bndrs')- join_arity = length final_bndrs'- final_join_bndr = (join_bndr `setIdArity` arity)- `asJoinId` join_arity- join_call = mkApps (Var final_join_bndr) final_args- final_join_bind = NonRec final_join_bndr join_rhs-- ; env' <- addPolyBind NotTopLevel env final_join_bind- ; return (env', (con, bndrs', join_call)) }- -- See Note [Duplicated env]--{--Note [Fusing case continuations]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's important to fuse two successive case continuations when the-first has one alternative. That's why we call prepareCaseCont here.-Consider this, which arises from thunk splitting (see Note [Thunk-splitting] in WorkWrap):-- let- x* = case (case v of {pn -> rn}) of- I# a -> I# a- in body--The simplifier will find- (Var v) with continuation- Select (pn -> rn) (- Select [I# a -> I# a] (- StrictBind body Stop--So we'll call mkDupableCont on- Select [I# a -> I# a] (StrictBind body Stop)-There is just one alternative in the first Select, so we want to-simplify the rhs (I# a) with continuation (StricgtBind body Stop)-Supposing that body is big, we end up with- let $j a = <let x = I# a in body>- in case v of { pn -> case rn of- I# a -> $j a }-This is just what we want because the rn produces a box that-the case rn cancels with.--See Trac #4957 a fuller example.--Note [Case binders and join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider this- case (case .. ) of c {- I# c# -> ....c....--If we make a join point with c but not c# we get- $j = \c -> ....c....--But if later inlining scrutinises the c, thus-- $j = \c -> ... case c of { I# y -> ... } ...--we won't see that 'c' has already been scrutinised. This actually-happens in the 'tabulate' function in wave4main, and makes a significant-difference to allocation.--An alternative plan is this:-- $j = \c# -> let c = I# c# in ...c....--but that is bad if 'c' is *not* later scrutinised.--So instead we do both: we pass 'c' and 'c#' , and record in c's inlining-(a stable unfolding) that it's really I# c#, thus-- $j = \c# -> \c[=I# c#] -> ...c....--Absence analysis may later discard 'c'.--NB: take great care when doing strictness analysis;- see Note [Lambda-bound unfoldings] in DmdAnal.--Also note that we can still end up passing stuff that isn't used. Before-strictness analysis we have- let $j x y c{=(x,y)} = (h c, ...)- in ...-After strictness analysis we see that h is strict, we end up with- let $j x y c{=(x,y)} = ($wh x y, ...)-and c is unused.--Note [Duplicated env]-~~~~~~~~~~~~~~~~~~~~~-Some of the alternatives are simplified, but have not been turned into a join point-So they *must* have an zapped subst-env. So we can't use completeNonRecX to-bind the join point, because it might to do PostInlineUnconditionally, and-we'd lose that when zapping the subst-env. We could have a per-alt subst-env,-but zapping it (as we do in mkDupableCont, the Select case) is safe, and-at worst delays the join-point inlining.--Note [Small alternative rhs]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It is worth checking for a small RHS because otherwise we-get extra let bindings that may cause an extra iteration of the simplifier to-inline back in place. Quite often the rhs is just a variable or constructor.-The Ord instance of Maybe in PrelMaybe.hs, for example, took several extra-iterations because the version with the let bindings looked big, and so wasn't-inlined, but after the join points had been inlined it looked smaller, and so-was inlined.--NB: we have to check the size of rhs', not rhs.-Duplicating a small InAlt might invalidate occurrence information-However, if it *is* dupable, we return the *un* simplified alternative,-because otherwise we'd need to pair it up with an empty subst-env....-but we only have one env shared between all the alts.-(Remember we must zap the subst-env before re-simplifying something).-Rather than do this we simply agree to re-simplify the original (small) thing later.--Note [Funky mkLamTypes]-~~~~~~~~~~~~~~~~~~~~~~-Notice the funky mkLamTypes. If the constructor has existentials-it's possible that the join point will be abstracted over-type variables as well as term variables.- Example: Suppose we have- data T = forall t. C [t]- Then faced with- case (case e of ...) of- C t xs::[t] -> rhs- We get the join point- let j :: forall t. [t] -> ...- j = /\t \xs::[t] -> rhs- in- case (case e of ...) of- C t xs::[t] -> j t xs--Note [Join point abstraction]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~--NB: This note is now historical. Now that "join point" is not a fuzzy concept-but a formal syntactic construct (as distinguished by the JoinId constructor of-IdDetails), each of these concerns is handled separately, with no need for a-vestigial extra argument.--Join points always have at least one value argument,-for several reasons--* If we try to lift a primitive-typed something out- for let-binding-purposes, we will *caseify* it (!),- with potentially-disastrous strictness results. So- instead we turn it into a function: \v -> e- where v::Void#. The value passed to this function is void,- which generates (almost) no code.--* CPR. We used to say "&& isUnliftedType rhs_ty'" here, but now- we make the join point into a function whenever used_bndrs'- is empty. This makes the join-point more CPR friendly.- Consider: let j = if .. then I# 3 else I# 4- in case .. of { A -> j; B -> j; C -> ... }-- Now CPR doesn't w/w j because it's a thunk, so- that means that the enclosing function can't w/w either,- which is a lose. Here's the example that happened in practice:- kgmod :: Int -> Int -> Int- kgmod x y = if x > 0 && y < 0 || x < 0 && y > 0- then 78- else 5--* Let-no-escape. We want a join point to turn into a let-no-escape- so that it is implemented as a jump, and one of the conditions- for LNE is that it's not updatable. In CoreToStg, see- Note [What is a non-escaping let]--* Floating. Since a join point will be entered once, no sharing is- gained by floating out, but something might be lost by doing- so because it might be allocated.--I have seen a case alternative like this:- True -> \v -> ...-It's a bit silly to add the realWorld dummy arg in this case, making- $j = \s v -> ...- True -> $j s-(the \v alone is enough to make CPR happy) but I think it's rare--There's a slight infelicity here: we pass the overall-case_bndr to all the join points if it's used in *any* RHS,-because we don't know its usage in each RHS separately---Note [Duplicating StrictArg]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The original plan had (where E is a big argument)-e.g. f E [..hole..]- ==> let $j = \a -> f E a- in $j [..hole..]--But this is terrible! Here's an example:- && E (case x of { T -> F; F -> T })-Now, && is strict so we end up simplifying the case with--an ArgOf continuation. If we let-bind it, we get- let $j = \v -> && E v- in simplExpr (case x of { T -> F; F -> T })- (ArgOf (\r -> $j r)-And after simplifying more we get- let $j = \v -> && E v- in case x of { T -> $j F; F -> $j T }-Which is a Very Bad Thing--What we do now is this- f E [..hole..]- ==> let a = E- in f a [..hole..]-Now if the thing in the hole is a case expression (which is when-we'll call mkDupableCont), we'll push the function call into the-branches, which is what we want. Now RULES for f may fire, and-call-pattern specialisation. Here's an example from Trac #3116- go (n+1) (case l of- 1 -> bs'- _ -> Chunk p fpc (o+1) (l-1) bs')-If we can push the call for 'go' inside the case, we get-call-pattern specialisation for 'go', which is *crucial* for-this program.--Here is the (&&) example:- && E (case x of { T -> F; F -> T })- ==> let a = E in- case x of { T -> && a F; F -> && a T }-Much better!--Notice that- * Arguments to f *after* the strict one are handled by- the ApplyToVal case of mkDupableCont. Eg- f [..hole..] E-- * We can only do the let-binding of E because the function- part of a StrictArg continuation is an explicit syntax- tree. In earlier versions we represented it as a function- (CoreExpr -> CoreEpxr) which we couldn't take apart.--Do *not* duplicate StrictBind and StritArg continuations. We gain-nothing by propagating them into the expressions, and we do lose a-lot.--The desire not to duplicate is the entire reason that-mkDupableCont returns a pair of continuations.--Note [Duplicating StrictBind]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Unlike StrictArg, there doesn't seem anything to gain from-duplicating a StrictBind continuation, so we don't.---************************************************************************-* *- Unfoldings-* *-************************************************************************--}--simplLetUnfolding :: SimplEnv-> TopLevelFlag- -> Maybe SimplCont- -> InId- -> OutExpr- -> Unfolding -> SimplM Unfolding-simplLetUnfolding env top_lvl cont_mb id new_rhs unf- | isStableUnfolding unf- = simplUnfolding env top_lvl cont_mb id unf- | otherwise- = is_bottoming `seq` -- See Note [Force bottoming field]- do { dflags <- getDynFlags- ; return (mkUnfolding dflags InlineRhs is_top_lvl is_bottoming new_rhs) }- -- We make an unfolding *even for loop-breakers*.- -- Reason: (a) It might be useful to know that they are WHNF- -- (b) In TidyPgm we currently assume that, if we want to- -- expose the unfolding then indeed we *have* an unfolding- -- to expose. (We could instead use the RHS, but currently- -- we don't.) The simple thing is always to have one.- where- is_top_lvl = isTopLevel top_lvl- is_bottoming = isBottomingId id--simplUnfolding :: SimplEnv -> TopLevelFlag- -> Maybe SimplCont -- Just k => a join point with continuation k- -> InId- -> Unfolding -> SimplM Unfolding--- Note [Setting the new unfolding]-simplUnfolding env top_lvl mb_cont id unf- = case unf of- NoUnfolding -> return unf- BootUnfolding -> return unf- OtherCon {} -> return unf-- DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = args }- -> do { (env', bndrs') <- simplBinders rule_env bndrs- ; args' <- mapM (simplExpr env') args- ; return (mkDFunUnfolding bndrs' con args') }-- CoreUnfolding { uf_tmpl = expr, uf_src = src, uf_guidance = guide }- | isStableSource src- -> do { expr' <- case mb_cont of- Just cont -> simplJoinRhs rule_env id expr cont- Nothing -> simplExpr rule_env expr- ; case guide of- UnfWhen { ug_arity = arity, ug_unsat_ok = sat_ok } -- Happens for INLINE things- -> let guide' = UnfWhen { ug_arity = arity, ug_unsat_ok = sat_ok- , ug_boring_ok = inlineBoringOk expr' }- -- Refresh the boring-ok flag, in case expr'- -- has got small. This happens, notably in the inlinings- -- for dfuns for single-method classes; see- -- Note [Single-method classes] in TcInstDcls.- -- A test case is Trac #4138- in return (mkCoreUnfolding src is_top_lvl expr' guide')- -- See Note [Top-level flag on inline rules] in CoreUnfold-- _other -- Happens for INLINABLE things- -> is_bottoming `seq` -- See Note [Force bottoming field]- do { dflags <- getDynFlags- ; return (mkUnfolding dflags src is_top_lvl is_bottoming expr') } }- -- If the guidance is UnfIfGoodArgs, this is an INLINABLE- -- unfolding, and we need to make sure the guidance is kept up- -- to date with respect to any changes in the unfolding.-- | otherwise -> return noUnfolding -- Discard unstable unfoldings- where- is_top_lvl = isTopLevel top_lvl- is_bottoming = isBottomingId id- act = idInlineActivation id- rule_env = updMode (updModeForStableUnfoldings act) env- -- See Note [Simplifying inside stable unfoldings] in SimplUtils--{--Note [Force bottoming field]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We need to force bottoming, or the new unfolding holds-on to the old unfolding (which is part of the id).--Note [Setting the new unfolding]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-* If there's an INLINE pragma, we simplify the RHS gently. Maybe we- should do nothing at all, but simplifying gently might get rid of- more crap.--* If not, we make an unfolding from the new RHS. But *only* for- non-loop-breakers. Making loop breakers not have an unfolding at all- means that we can avoid tests in exprIsConApp, for example. This is- important: if exprIsConApp says 'yes' for a recursive thing, then we- can get into an infinite loop--If there's an stable unfolding on a loop breaker (which happens for+import GhcPrelude++import DynFlags+import SimplMonad+import Type hiding ( substTy, substTyVar, extendTvSubst, extendCvSubst )+import SimplEnv+import SimplUtils+import OccurAnal ( occurAnalyseExpr )+import FamInstEnv ( FamInstEnv )+import Literal ( litIsLifted ) --, mkMachInt ) -- temporalily commented out. See #8326+import Id+import MkId ( seqId )+import MkCore ( mkImpossibleExpr, castBottomExpr )+import IdInfo+import Name ( Name, mkSystemVarName, isExternalName, getOccFS )+import Coercion hiding ( substCo, substCoVar )+import OptCoercion ( optCoercion )+import FamInstEnv ( topNormaliseType_maybe )+import DataCon ( DataCon, dataConWorkId, dataConRepStrictness, dataConRepArgTys )+import CoreMonad ( Tick(..), SimplMode(..) )+import CoreSyn+import Demand ( StrictSig(..), dmdTypeDepth, isStrictDmd )+import PprCore ( pprCoreExpr )+import CoreUnfold+import CoreUtils+import CoreOpt ( pushCoTyArg, pushCoValArg+ , joinPointBinding_maybe, joinPointBindings_maybe )+import Rules ( mkRuleInfo, lookupRule, getRules )+import Demand ( mkClosedStrictSig, topDmd, exnRes )+import BasicTypes ( TopLevelFlag(..), isNotTopLevel, isTopLevel,+ RecFlag(..), Arity )+import MonadUtils ( mapAccumLM, liftIO )+import Maybes ( orElse )+import Control.Monad+import Outputable+import FastString+import Pair+import Util+import ErrUtils+import Module ( moduleName, pprModuleName )+++{-+The guts of the simplifier is in this module, but the driver loop for+the simplifier is in SimplCore.hs.++Note [The big picture]+~~~~~~~~~~~~~~~~~~~~~~+The general shape of the simplifier is this:++ simplExpr :: SimplEnv -> InExpr -> SimplCont -> SimplM (SimplFloats, OutExpr)+ simplBind :: SimplEnv -> InBind -> SimplM (SimplFloats, SimplEnv)++ * SimplEnv contains+ - Simplifier mode (which includes DynFlags for convenience)+ - Ambient substitution+ - InScopeSet++ * SimplFloats contains+ - Let-floats (which includes ok-for-spec case-floats)+ - Join floats+ - InScopeSet (including all the floats)++ * Expressions+ simplExpr :: SimplEnv -> InExpr -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+ The result of simplifying an /expression/ is (floats, expr)+ - A bunch of floats (let bindings, join bindings)+ - A simplified expression.+ The overall result is effectively (let floats in expr)++ * Bindings+ simplBind :: SimplEnv -> InBind -> SimplM (SimplFloats, SimplEnv)+ The result of simplifying a binding is+ - A bunch of floats, the last of which is the simplified binding+ There may be auxiliary bindings too; see prepareRhs+ - An environment suitable for simplifying the scope of the binding++ The floats may also be empty, if the binding is inlined unconditionally;+ in that case the returned SimplEnv will have an augmented substitution.++ The returned floats and env both have an in-scope set, and they are+ guaranteed to be the same.+++Note [Shadowing]+~~~~~~~~~~~~~~~~+The simplifier used to guarantee that the output had no shadowing, but+it does not do so any more. (Actually, it never did!) The reason is+documented with simplifyArgs.+++Eta expansion+~~~~~~~~~~~~~~+For eta expansion, we want to catch things like++ case e of (a,b) -> \x -> case a of (p,q) -> \y -> r++If the \x was on the RHS of a let, we'd eta expand to bring the two+lambdas together. And in general that's a good thing to do. Perhaps+we should eta expand wherever we find a (value) lambda? Then the eta+expansion at a let RHS can concentrate solely on the PAP case.++************************************************************************+* *+\subsection{Bindings}+* *+************************************************************************+-}++simplTopBinds :: SimplEnv -> [InBind] -> SimplM (SimplFloats, SimplEnv)+-- See Note [The big picture]+simplTopBinds env0 binds0+ = do { -- Put all the top-level binders into scope at the start+ -- so that if a transformation rule has unexpectedly brought+ -- anything into scope, then we don't get a complaint about that.+ -- It's rather as if the top-level binders were imported.+ -- See note [Glomming] in OccurAnal.+ ; env1 <- simplRecBndrs env0 (bindersOfBinds binds0)+ ; (floats, env2) <- simpl_binds env1 binds0+ ; freeTick SimplifierDone+ ; return (floats, env2) }+ where+ -- We need to track the zapped top-level binders, because+ -- they should have their fragile IdInfo zapped (notably occurrence info)+ -- That's why we run down binds and bndrs' simultaneously.+ --+ simpl_binds :: SimplEnv -> [InBind] -> SimplM (SimplFloats, SimplEnv)+ simpl_binds env [] = return (emptyFloats env, env)+ simpl_binds env (bind:binds) = do { (float, env1) <- simpl_bind env bind+ ; (floats, env2) <- simpl_binds env1 binds+ ; return (float `addFloats` floats, env2) }++ simpl_bind env (Rec pairs) = simplRecBind env TopLevel Nothing pairs+ simpl_bind env (NonRec b r) = do { (env', b') <- addBndrRules env b (lookupRecBndr env b)+ ; simplRecOrTopPair env' TopLevel+ NonRecursive Nothing+ b b' r }++{-+************************************************************************+* *+ Lazy bindings+* *+************************************************************************++simplRecBind is used for+ * recursive bindings only+-}++simplRecBind :: SimplEnv -> TopLevelFlag -> Maybe SimplCont+ -> [(InId, InExpr)]+ -> SimplM (SimplFloats, SimplEnv)+simplRecBind env0 top_lvl mb_cont pairs0+ = do { (env_with_info, triples) <- mapAccumLM add_rules env0 pairs0+ ; (rec_floats, env1) <- go env_with_info triples+ ; return (mkRecFloats rec_floats, env1) }+ where+ add_rules :: SimplEnv -> (InBndr,InExpr) -> SimplM (SimplEnv, (InBndr, OutBndr, InExpr))+ -- Add the (substituted) rules to the binder+ add_rules env (bndr, rhs)+ = do { (env', bndr') <- addBndrRules env bndr (lookupRecBndr env bndr)+ ; return (env', (bndr, bndr', rhs)) }++ go env [] = return (emptyFloats env, env)++ go env ((old_bndr, new_bndr, rhs) : pairs)+ = do { (float, env1) <- simplRecOrTopPair env top_lvl Recursive mb_cont+ old_bndr new_bndr rhs+ ; (floats, env2) <- go env1 pairs+ ; return (float `addFloats` floats, env2) }++{-+simplOrTopPair is used for+ * recursive bindings (whether top level or not)+ * top-level non-recursive bindings++It assumes the binder has already been simplified, but not its IdInfo.+-}++simplRecOrTopPair :: SimplEnv+ -> TopLevelFlag -> RecFlag -> Maybe SimplCont+ -> InId -> OutBndr -> InExpr -- Binder and rhs+ -> SimplM (SimplFloats, SimplEnv)++simplRecOrTopPair env top_lvl is_rec mb_cont old_bndr new_bndr rhs+ | preInlineUnconditionally env top_lvl old_bndr rhs+ = trace_bind "pre-inline-uncond" $+ do { tick (PreInlineUnconditionally old_bndr)+ ; return ( emptyFloats env+ , extendIdSubst env old_bndr (mkContEx env rhs)) }++ | Just cont <- mb_cont+ = ASSERT( isNotTopLevel top_lvl && isJoinId new_bndr )+ trace_bind "join" $+ simplJoinBind env cont old_bndr new_bndr rhs env++ | otherwise+ = trace_bind "normal" $+ simplLazyBind env top_lvl is_rec old_bndr new_bndr rhs env++ where+ dflags = seDynFlags env++ -- trace_bind emits a trace for each top-level binding, which+ -- helps to locate the tracing for inlining and rule firing+ trace_bind what thing_inside+ | not (dopt Opt_D_verbose_core2core dflags)+ = thing_inside+ | otherwise+ = pprTrace ("SimplBind " ++ what) (ppr old_bndr) thing_inside++--------------------------+simplLazyBind :: SimplEnv+ -> TopLevelFlag -> RecFlag+ -> InId -> OutId -- Binder, both pre-and post simpl+ -- Not a JoinId+ -- The OutId has IdInfo, except arity, unfolding+ -- Ids only, no TyVars+ -> InExpr -> SimplEnv -- The RHS and its environment+ -> SimplM (SimplFloats, SimplEnv)+-- Precondition: not a JoinId+-- Precondition: rhs obeys the let/app invariant+-- NOT used for JoinIds+simplLazyBind env top_lvl is_rec bndr bndr1 rhs rhs_se+ = ASSERT( isId bndr )+ ASSERT2( not (isJoinId bndr), ppr bndr )+ -- pprTrace "simplLazyBind" ((ppr bndr <+> ppr bndr1) $$ ppr rhs $$ ppr (seIdSubst rhs_se)) $+ do { let rhs_env = rhs_se `setInScopeFromE` env+ (tvs, body) = case collectTyAndValBinders rhs of+ (tvs, [], body)+ | surely_not_lam body -> (tvs, body)+ _ -> ([], rhs)++ surely_not_lam (Lam {}) = False+ surely_not_lam (Tick t e)+ | not (tickishFloatable t) = surely_not_lam e+ -- eta-reduction could float+ surely_not_lam _ = True+ -- Do not do the "abstract tyyvar" thing if there's+ -- a lambda inside, because it defeats eta-reduction+ -- f = /\a. \x. g a x+ -- should eta-reduce.+++ ; (body_env, tvs') <- simplBinders rhs_env tvs+ -- See Note [Floating and type abstraction] in SimplUtils++ -- Simplify the RHS+ ; let rhs_cont = mkRhsStop (substTy body_env (exprType body))+ ; (body_floats0, body0) <- simplExprF body_env body rhs_cont++ -- Never float join-floats out of a non-join let-binding+ -- So wrap the body in the join-floats right now+ -- Henc: body_floats1 consists only of let-floats+ ; let (body_floats1, body1) = wrapJoinFloatsX body_floats0 body0++ -- ANF-ise a constructor or PAP rhs+ -- We get at most one float per argument here+ ; (let_floats, body2) <- prepareRhs (getMode env) top_lvl+ (getOccFS bndr1) (idInfo bndr1) body1+ ; let body_floats2 = body_floats1 `addLetFloats` let_floats++ ; (rhs_floats, rhs')+ <- if not (doFloatFromRhs top_lvl is_rec False body_floats2 body2)+ then -- No floating, revert to body1+ do { rhs' <- mkLam env tvs' (wrapFloats body_floats2 body1) rhs_cont+ ; return (emptyFloats env, rhs') }++ else if null tvs then -- Simple floating+ do { tick LetFloatFromLet+ ; return (body_floats2, body2) }++ else -- Do type-abstraction first+ do { tick LetFloatFromLet+ ; (poly_binds, body3) <- abstractFloats (seDynFlags env) top_lvl+ tvs' body_floats2 body2+ ; let floats = foldl extendFloats (emptyFloats env) poly_binds+ ; rhs' <- mkLam env tvs' body3 rhs_cont+ ; return (floats, rhs') }++ ; (bind_float, env2) <- completeBind (env `setInScopeFromF` rhs_floats)+ top_lvl Nothing bndr bndr1 rhs'+ ; return (rhs_floats `addFloats` bind_float, env2) }++--------------------------+simplJoinBind :: SimplEnv+ -> SimplCont+ -> InId -> OutId -- Binder, both pre-and post simpl+ -- The OutId has IdInfo, except arity,+ -- unfolding+ -> InExpr -> SimplEnv -- The right hand side and its env+ -> SimplM (SimplFloats, SimplEnv)+simplJoinBind env cont old_bndr new_bndr rhs rhs_se+ = do { let rhs_env = rhs_se `setInScopeFromE` env+ ; rhs' <- simplJoinRhs rhs_env old_bndr rhs cont+ ; completeBind env NotTopLevel (Just cont) old_bndr new_bndr rhs' }++--------------------------+simplNonRecX :: SimplEnv+ -> InId -- Old binder; not a JoinId+ -> OutExpr -- Simplified RHS+ -> SimplM (SimplFloats, SimplEnv)+-- A specialised variant of simplNonRec used when the RHS is already+-- simplified, notably in knownCon. It uses case-binding where necessary.+--+-- Precondition: rhs satisfies the let/app invariant++simplNonRecX env bndr new_rhs+ | ASSERT2( not (isJoinId bndr), ppr bndr )+ isDeadBinder bndr -- Not uncommon; e.g. case (a,b) of c { (p,q) -> p }+ = return (emptyFloats env, env) -- Here c is dead, and we avoid+ -- creating the binding c = (a,b)++ | Coercion co <- new_rhs+ = return (emptyFloats env, extendCvSubst env bndr co)++ | otherwise+ = do { (env', bndr') <- simplBinder env bndr+ ; completeNonRecX NotTopLevel env' (isStrictId bndr) bndr bndr' new_rhs }+ -- simplNonRecX is only used for NotTopLevel things++--------------------------+completeNonRecX :: TopLevelFlag -> SimplEnv+ -> Bool+ -> InId -- Old binder; not a JoinId+ -> OutId -- New binder+ -> OutExpr -- Simplified RHS+ -> SimplM (SimplFloats, SimplEnv) -- The new binding is in the floats+-- Precondition: rhs satisfies the let/app invariant+-- See Note [CoreSyn let/app invariant] in CoreSyn++completeNonRecX top_lvl env is_strict old_bndr new_bndr new_rhs+ = ASSERT2( not (isJoinId new_bndr), ppr new_bndr )+ do { (prepd_floats, rhs1) <- prepareRhs (getMode env) top_lvl (getOccFS new_bndr)+ (idInfo new_bndr) new_rhs+ ; let floats = emptyFloats env `addLetFloats` prepd_floats+ ; (rhs_floats, rhs2) <-+ if doFloatFromRhs NotTopLevel NonRecursive is_strict floats rhs1+ then -- Add the floats to the main env+ do { tick LetFloatFromLet+ ; return (floats, rhs1) }+ else -- Do not float; wrap the floats around the RHS+ return (emptyFloats env, wrapFloats floats rhs1)++ ; (bind_float, env2) <- completeBind (env `setInScopeFromF` rhs_floats)+ NotTopLevel Nothing+ old_bndr new_bndr rhs2+ ; return (rhs_floats `addFloats` bind_float, env2) }+++{- *********************************************************************+* *+ prepareRhs, makeTrivial+* *+************************************************************************++Note [prepareRhs]+~~~~~~~~~~~~~~~~~+prepareRhs takes a putative RHS, checks whether it's a PAP or+constructor application and, if so, converts it to ANF, so that the+resulting thing can be inlined more easily. Thus+ x = (f a, g b)+becomes+ t1 = f a+ t2 = g b+ x = (t1,t2)++We also want to deal well cases like this+ v = (f e1 `cast` co) e2+Here we want to make e1,e2 trivial and get+ x1 = e1; x2 = e2; v = (f x1 `cast` co) v2+That's what the 'go' loop in prepareRhs does+-}++prepareRhs :: SimplMode -> TopLevelFlag+ -> FastString -- Base for any new variables+ -> IdInfo -- IdInfo for the LHS of this binding+ -> OutExpr+ -> SimplM (LetFloats, OutExpr)+-- Transforms a RHS into a better RHS by adding floats+-- e.g x = Just e+-- becomes a = e+-- x = Just a+-- See Note [prepareRhs]+prepareRhs mode top_lvl occ info (Cast rhs co) -- Note [Float coercions]+ | Pair ty1 _ty2 <- coercionKind co -- Do *not* do this if rhs has an unlifted type+ , not (isUnliftedType ty1) -- see Note [Float coercions (unlifted)]+ = do { (floats, rhs') <- makeTrivialWithInfo mode top_lvl occ sanitised_info rhs+ ; return (floats, Cast rhs' co) }+ where+ sanitised_info = vanillaIdInfo `setStrictnessInfo` strictnessInfo info+ `setDemandInfo` demandInfo info++prepareRhs mode top_lvl occ _ rhs0+ = do { (_is_exp, floats, rhs1) <- go 0 rhs0+ ; return (floats, rhs1) }+ where+ go :: Int -> OutExpr -> SimplM (Bool, LetFloats, OutExpr)+ go n_val_args (Cast rhs co)+ = do { (is_exp, floats, rhs') <- go n_val_args rhs+ ; return (is_exp, floats, Cast rhs' co) }+ go n_val_args (App fun (Type ty))+ = do { (is_exp, floats, rhs') <- go n_val_args fun+ ; return (is_exp, floats, App rhs' (Type ty)) }+ go n_val_args (App fun arg)+ = do { (is_exp, floats1, fun') <- go (n_val_args+1) fun+ ; case is_exp of+ False -> return (False, emptyLetFloats, App fun arg)+ True -> do { (floats2, arg') <- makeTrivial mode top_lvl occ arg+ ; return (True, floats1 `addLetFlts` floats2, App fun' arg') } }+ go n_val_args (Var fun)+ = return (is_exp, emptyLetFloats, Var fun)+ where+ is_exp = isExpandableApp fun n_val_args -- The fun a constructor or PAP+ -- See Note [CONLIKE pragma] in BasicTypes+ -- The definition of is_exp should match that in+ -- OccurAnal.occAnalApp++ go n_val_args (Tick t rhs)+ -- We want to be able to float bindings past this+ -- tick. Non-scoping ticks don't care.+ | tickishScoped t == NoScope+ = do { (is_exp, floats, rhs') <- go n_val_args rhs+ ; return (is_exp, floats, Tick t rhs') }++ -- On the other hand, for scoping ticks we need to be able to+ -- copy them on the floats, which in turn is only allowed if+ -- we can obtain non-counting ticks.+ | (not (tickishCounts t) || tickishCanSplit t)+ = do { (is_exp, floats, rhs') <- go n_val_args rhs+ ; let tickIt (id, expr)+ -- we have to take care not to tick top-level literal+ -- strings. See Note [CoreSyn top-level string literals].+ | isTopLevel top_lvl && exprIsLiteralString expr+ = (id, expr)+ | otherwise+ = (id, mkTick (mkNoCount t) expr)+ floats' = mapLetFloats floats tickIt+ ; return (is_exp, floats', Tick t rhs') }++ go _ other+ = return (False, emptyLetFloats, other)++{-+Note [Float coercions]+~~~~~~~~~~~~~~~~~~~~~~+When we find the binding+ x = e `cast` co+we'd like to transform it to+ x' = e+ x = x `cast` co -- A trivial binding+There's a chance that e will be a constructor application or function, or something+like that, so moving the coercion to the usage site may well cancel the coercions+and lead to further optimisation. Example:++ data family T a :: *+ data instance T Int = T Int++ foo :: Int -> Int -> Int+ foo m n = ...+ where+ x = T m+ go 0 = 0+ go n = case x of { T m -> go (n-m) }+ -- This case should optimise++Note [Preserve strictness when floating coercions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In the Note [Float coercions] transformation, keep the strictness info.+Eg+ f = e `cast` co -- f has strictness SSL+When we transform to+ f' = e -- f' also has strictness SSL+ f = f' `cast` co -- f still has strictness SSL++Its not wrong to drop it on the floor, but better to keep it.++Note [Float coercions (unlifted)]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+BUT don't do [Float coercions] if 'e' has an unlifted type.+This *can* happen:++ foo :: Int = (error (# Int,Int #) "urk")+ `cast` CoUnsafe (# Int,Int #) Int++If do the makeTrivial thing to the error call, we'll get+ foo = case error (# Int,Int #) "urk" of v -> v `cast` ...+But 'v' isn't in scope!++These strange casts can happen as a result of case-of-case+ bar = case (case x of { T -> (# 2,3 #); F -> error "urk" }) of+ (# p,q #) -> p+q+-}++makeTrivialArg :: SimplMode -> ArgSpec -> SimplM (LetFloats, ArgSpec)+makeTrivialArg mode (ValArg e)+ = do { (floats, e') <- makeTrivial mode NotTopLevel (fsLit "arg") e+ ; return (floats, ValArg e') }+makeTrivialArg _ arg+ = return (emptyLetFloats, arg) -- CastBy, TyArg++makeTrivial :: SimplMode -> TopLevelFlag+ -> FastString -- ^ A "friendly name" to build the new binder from+ -> OutExpr -- ^ This expression satisfies the let/app invariant+ -> SimplM (LetFloats, OutExpr)+-- Binds the expression to a variable, if it's not trivial, returning the variable+makeTrivial mode top_lvl context expr+ = makeTrivialWithInfo mode top_lvl context vanillaIdInfo expr++makeTrivialWithInfo :: SimplMode -> TopLevelFlag+ -> FastString -- ^ a "friendly name" to build the new binder from+ -> IdInfo+ -> OutExpr -- ^ This expression satisfies the let/app invariant+ -> SimplM (LetFloats, OutExpr)+-- Propagate strictness and demand info to the new binder+-- Note [Preserve strictness when floating coercions]+-- Returned SimplEnv has same substitution as incoming one+makeTrivialWithInfo mode top_lvl occ_fs info expr+ | exprIsTrivial expr -- Already trivial+ || not (bindingOk top_lvl expr expr_ty) -- Cannot trivialise+ -- See Note [Cannot trivialise]+ = return (emptyLetFloats, expr)++ | otherwise+ = do { (floats, expr1) <- prepareRhs mode top_lvl occ_fs info expr+ ; if exprIsTrivial expr1 -- See Note [Trivial after prepareRhs]+ then return (floats, expr1)+ else do+ { uniq <- getUniqueM+ ; let name = mkSystemVarName uniq occ_fs+ var = mkLocalIdOrCoVarWithInfo name expr_ty info++ -- Now something very like completeBind,+ -- but without the postInlineUnconditinoally part+ ; (arity, is_bot, expr2) <- tryEtaExpandRhs mode var expr1+ ; unf <- mkLetUnfolding (sm_dflags mode) top_lvl InlineRhs var expr2++ ; let final_id = addLetBndrInfo var arity is_bot unf+ bind = NonRec final_id expr2++ ; return ( floats `addLetFlts` unitLetFloat bind, Var final_id ) }}+ where+ expr_ty = exprType expr++bindingOk :: TopLevelFlag -> CoreExpr -> Type -> Bool+-- True iff we can have a binding of this expression at this level+-- Precondition: the type is the type of the expression+bindingOk top_lvl expr expr_ty+ | isTopLevel top_lvl = exprIsTopLevelBindable expr expr_ty+ | otherwise = True++{- Note [Trivial after prepareRhs]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we call makeTrival on (e |> co), the recursive use of prepareRhs+may leave us with+ { a1 = e } and (a1 |> co)+Now the latter is trivial, so we don't want to let-bind it.++Note [Cannot trivialise]+~~~~~~~~~~~~~~~~~~~~~~~~+Consider:+ f :: Int -> Addr#++ foo :: Bar+ foo = Bar (f 3)++Then we can't ANF-ise foo, even though we'd like to, because+we can't make a top-level binding for the Addr# (f 3). And if+so we don't want to turn it into+ foo = let x = f 3 in Bar x+because we'll just end up inlining x back, and that makes the+simplifier loop. Better not to ANF-ise it at all.++Literal strings are an exception.++ foo = Ptr "blob"#++We want to turn this into:++ foo1 = "blob"#+ foo = Ptr foo1++See Note [CoreSyn top-level string literals] in CoreSyn.++************************************************************************+* *+ Completing a lazy binding+* *+************************************************************************++completeBind+ * deals only with Ids, not TyVars+ * takes an already-simplified binder and RHS+ * is used for both recursive and non-recursive bindings+ * is used for both top-level and non-top-level bindings++It does the following:+ - tries discarding a dead binding+ - tries PostInlineUnconditionally+ - add unfolding [this is the only place we add an unfolding]+ - add arity++It does *not* attempt to do let-to-case. Why? Because it is used for+ - top-level bindings (when let-to-case is impossible)+ - many situations where the "rhs" is known to be a WHNF+ (so let-to-case is inappropriate).++Nor does it do the atomic-argument thing+-}++completeBind :: SimplEnv+ -> TopLevelFlag -- Flag stuck into unfolding+ -> Maybe SimplCont -- Required only for join point+ -> InId -- Old binder+ -> OutId -> OutExpr -- New binder and RHS+ -> SimplM (SimplFloats, SimplEnv)+-- completeBind may choose to do its work+-- * by extending the substitution (e.g. let x = y in ...)+-- * or by adding to the floats in the envt+--+-- Binder /can/ be a JoinId+-- Precondition: rhs obeys the let/app invariant+completeBind env top_lvl mb_cont old_bndr new_bndr new_rhs+ | isCoVar old_bndr+ = case new_rhs of+ Coercion co -> return (emptyFloats env, extendCvSubst env old_bndr co)+ _ -> return (mkFloatBind env (NonRec new_bndr new_rhs))++ | otherwise+ = ASSERT( isId new_bndr )+ do { let old_info = idInfo old_bndr+ old_unf = unfoldingInfo old_info+ occ_info = occInfo old_info++ -- Do eta-expansion on the RHS of the binding+ -- See Note [Eta-expanding at let bindings] in SimplUtils+ ; (new_arity, is_bot, final_rhs) <- tryEtaExpandRhs (getMode env)+ new_bndr new_rhs++ -- Simplify the unfolding+ ; new_unfolding <- simplLetUnfolding env top_lvl mb_cont old_bndr+ final_rhs old_unf++ ; let final_bndr = addLetBndrInfo new_bndr new_arity is_bot new_unfolding++ ; if postInlineUnconditionally env top_lvl final_bndr occ_info final_rhs++ then -- Inline and discard the binding+ do { tick (PostInlineUnconditionally old_bndr)+ ; return ( emptyFloats env+ , extendIdSubst env old_bndr $+ DoneEx final_rhs (isJoinId_maybe new_bndr)) }+ -- Use the substitution to make quite, quite sure that the+ -- substitution will happen, since we are going to discard the binding++ else -- Keep the binding+ -- pprTrace "Binding" (ppr final_bndr <+> ppr new_unfolding) $+ return (mkFloatBind env (NonRec final_bndr final_rhs)) }++addLetBndrInfo :: OutId -> Arity -> Bool -> Unfolding -> OutId+addLetBndrInfo new_bndr new_arity is_bot new_unf+ = new_bndr `setIdInfo` info5+ where+ info1 = idInfo new_bndr `setArityInfo` new_arity++ -- Unfolding info: Note [Setting the new unfolding]+ info2 = info1 `setUnfoldingInfo` new_unf++ -- Demand info: Note [Setting the demand info]+ -- We also have to nuke demand info if for some reason+ -- eta-expansion *reduces* the arity of the binding to less+ -- than that of the strictness sig. This can happen: see Note [Arity decrease].+ info3 | isEvaldUnfolding new_unf+ || (case strictnessInfo info2 of+ StrictSig dmd_ty -> new_arity < dmdTypeDepth dmd_ty)+ = zapDemandInfo info2 `orElse` info2+ | otherwise+ = info2++ -- Bottoming bindings: see Note [Bottoming bindings]+ info4 | is_bot = info3 `setStrictnessInfo`+ mkClosedStrictSig (replicate new_arity topDmd) exnRes+ | otherwise = info3++ -- Zap call arity info. We have used it by now (via+ -- `tryEtaExpandRhs`), and the simplifier can invalidate this+ -- information, leading to broken code later (e.g. #13479)+ info5 = zapCallArityInfo info4+++{- Note [Arity decrease]+~~~~~~~~~~~~~~~~~~~~~~~~+Generally speaking the arity of a binding should not decrease. But it *can*+legitimately happen because of RULES. Eg+ f = g Int+where g has arity 2, will have arity 2. But if there's a rewrite rule+ g Int --> h+where h has arity 1, then f's arity will decrease. Here's a real-life example,+which is in the output of Specialise:++ Rec {+ $dm {Arity 2} = \d.\x. op d+ {-# RULES forall d. $dm Int d = $s$dm #-}++ dInt = MkD .... opInt ...+ opInt {Arity 1} = $dm dInt++ $s$dm {Arity 0} = \x. op dInt }++Here opInt has arity 1; but when we apply the rule its arity drops to 0.+That's why Specialise goes to a little trouble to pin the right arity+on specialised functions too.++Note [Bottoming bindings]+~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we have+ let x = error "urk"+ in ...(case x of <alts>)...+or+ let f = \x. error (x ++ "urk")+ in ...(case f "foo" of <alts>)...++Then we'd like to drop the dead <alts> immediately. So it's good to+propagate the info that x's RHS is bottom to x's IdInfo as rapidly as+possible.++We use tryEtaExpandRhs on every binding, and it turns ou that the+arity computation it performs (via CoreArity.findRhsArity) already+does a simple bottoming-expression analysis. So all we need to do+is propagate that info to the binder's IdInfo.++This showed up in Trac #12150; see comment:16.++Note [Setting the demand info]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If the unfolding is a value, the demand info may+go pear-shaped, so we nuke it. Example:+ let x = (a,b) in+ case x of (p,q) -> h p q x+Here x is certainly demanded. But after we've nuked+the case, we'll get just+ let x = (a,b) in h a b x+and now x is not demanded (I'm assuming h is lazy)+This really happens. Similarly+ let f = \x -> e in ...f..f...+After inlining f at some of its call sites the original binding may+(for example) be no longer strictly demanded.+The solution here is a bit ad hoc...+++************************************************************************+* *+\subsection[Simplify-simplExpr]{The main function: simplExpr}+* *+************************************************************************++The reason for this OutExprStuff stuff is that we want to float *after*+simplifying a RHS, not before. If we do so naively we get quadratic+behaviour as things float out.++To see why it's important to do it after, consider this (real) example:++ let t = f x+ in fst t+==>+ let t = let a = e1+ b = e2+ in (a,b)+ in fst t+==>+ let a = e1+ b = e2+ t = (a,b)+ in+ a -- Can't inline a this round, cos it appears twice+==>+ e1++Each of the ==> steps is a round of simplification. We'd save a+whole round if we float first. This can cascade. Consider++ let f = g d+ in \x -> ...f...+==>+ let f = let d1 = ..d.. in \y -> e+ in \x -> ...f...+==>+ let d1 = ..d..+ in \x -> ...(\y ->e)...++Only in this second round can the \y be applied, and it+might do the same again.+-}++simplExpr :: SimplEnv -> CoreExpr -> SimplM CoreExpr+simplExpr env (Type ty)+ = do { ty' <- simplType env ty -- See Note [Avoiding space leaks in OutType]+ ; return (Type ty') }++simplExpr env expr+ = simplExprC env expr (mkBoringStop expr_out_ty)+ where+ expr_out_ty :: OutType+ expr_out_ty = substTy env (exprType expr)+ -- NB: Since 'expr' is term-valued, not (Type ty), this call+ -- to exprType will succeed. exprType fails on (Type ty).++simplExprC :: SimplEnv+ -> InExpr -- A term-valued expression, never (Type ty)+ -> SimplCont+ -> SimplM OutExpr+ -- Simplify an expression, given a continuation+simplExprC env expr cont+ = -- pprTrace "simplExprC" (ppr expr $$ ppr cont {- $$ ppr (seIdSubst env) -} $$ ppr (seLetFloats env) ) $+ do { (floats, expr') <- simplExprF env expr cont+ ; -- pprTrace "simplExprC ret" (ppr expr $$ ppr expr') $+ -- pprTrace "simplExprC ret3" (ppr (seInScope env')) $+ -- pprTrace "simplExprC ret4" (ppr (seLetFloats env')) $+ return (wrapFloats floats expr') }++--------------------------------------------------+simplExprF :: SimplEnv+ -> InExpr -- A term-valued expression, never (Type ty)+ -> SimplCont+ -> SimplM (SimplFloats, OutExpr)++simplExprF env e cont+ = {- pprTrace "simplExprF" (vcat+ [ ppr e+ , text "cont =" <+> ppr cont+ , text "inscope =" <+> ppr (seInScope env)+ , text "tvsubst =" <+> ppr (seTvSubst env)+ , text "idsubst =" <+> ppr (seIdSubst env)+ , text "cvsubst =" <+> ppr (seCvSubst env)+ ]) $ -}+ simplExprF1 env e cont++simplExprF1 :: SimplEnv -> InExpr -> SimplCont+ -> SimplM (SimplFloats, OutExpr)++simplExprF1 _ (Type ty) _+ = pprPanic "simplExprF: type" (ppr ty)+ -- simplExprF does only with term-valued expressions+ -- The (Type ty) case is handled separately by simplExpr+ -- and by the other callers of simplExprF++simplExprF1 env (Var v) cont = simplIdF env v cont+simplExprF1 env (Lit lit) cont = rebuild env (Lit lit) cont+simplExprF1 env (Tick t expr) cont = simplTick env t expr cont+simplExprF1 env (Cast body co) cont = simplCast env body co cont+simplExprF1 env (Coercion co) cont = simplCoercionF env co cont++simplExprF1 env (App fun arg) cont+ = case arg of+ Type ty -> do { -- The argument type will (almost) certainly be used+ -- in the output program, so just force it now.+ -- See Note [Avoiding space leaks in OutType]+ arg' <- simplType env ty++ -- But use substTy, not simplType, to avoid forcing+ -- the hole type; it will likely not be needed.+ -- See Note [The hole type in ApplyToTy]+ ; let hole' = substTy env (exprType fun)++ ; simplExprF env fun $+ ApplyToTy { sc_arg_ty = arg'+ , sc_hole_ty = hole'+ , sc_cont = cont } }+ _ -> simplExprF env fun $+ ApplyToVal { sc_arg = arg, sc_env = env+ , sc_dup = NoDup, sc_cont = cont }++simplExprF1 env expr@(Lam {}) cont+ = simplLam env zapped_bndrs body cont+ -- The main issue here is under-saturated lambdas+ -- (\x1. \x2. e) arg1+ -- Here x1 might have "occurs-once" occ-info, because occ-info+ -- is computed assuming that a group of lambdas is applied+ -- all at once. If there are too few args, we must zap the+ -- occ-info, UNLESS the remaining binders are one-shot+ where+ (bndrs, body) = collectBinders expr+ zapped_bndrs | need_to_zap = map zap bndrs+ | otherwise = bndrs++ need_to_zap = any zappable_bndr (drop n_args bndrs)+ n_args = countArgs cont+ -- NB: countArgs counts all the args (incl type args)+ -- and likewise drop counts all binders (incl type lambdas)++ zappable_bndr b = isId b && not (isOneShotBndr b)+ zap b | isTyVar b = b+ | otherwise = zapLamIdInfo b++simplExprF1 env (Case scrut bndr _ alts) cont+ = simplExprF env scrut (Select { sc_dup = NoDup, sc_bndr = bndr+ , sc_alts = alts+ , sc_env = env, sc_cont = cont })++simplExprF1 env (Let (Rec pairs) body) cont+ | Just pairs' <- joinPointBindings_maybe pairs+ = simplRecJoinPoint env pairs' body cont++ | otherwise+ = simplRecE env pairs body cont++simplExprF1 env (Let (NonRec bndr rhs) body) cont+ | Type ty <- rhs -- First deal with type lets (let a = Type ty in e)+ = ASSERT( isTyVar bndr )+ do { ty' <- simplType env ty+ ; simplExprF (extendTvSubst env bndr ty') body cont }++ | Just (bndr', rhs') <- joinPointBinding_maybe bndr rhs+ = simplNonRecJoinPoint env bndr' rhs' body cont++ | otherwise+ = simplNonRecE env bndr (rhs, env) ([], body) cont++{- Note [Avoiding space leaks in OutType]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Since the simplifier is run for multiple iterations, we need to ensure+that any thunks in the output of one simplifier iteration are forced+by the evaluation of the next simplifier iteration. Otherwise we may+retain multiple copies of the Core program and leak a terrible amount+of memory (as in #13426).++The simplifier is naturally strict in the entire "Expr part" of the+input Core program, because any expression may contain binders, which+we must find in order to extend the SimplEnv accordingly. But types+do not contain binders and so it is tempting to write things like++ simplExpr env (Type ty) = return (Type (substTy env ty)) -- Bad!++This is Bad because the result includes a thunk (substTy env ty) which+retains a reference to the whole simplifier environment; and the next+simplifier iteration will not force this thunk either, because the+line above is not strict in ty.++So instead our strategy is for the simplifier to fully evaluate+OutTypes when it emits them into the output Core program, for example++ simplExpr env (Type ty) = do { ty' <- simplType env ty -- Good+ ; return (Type ty') }++where the only difference from above is that simplType calls seqType+on the result of substTy.++However, SimplCont can also contain OutTypes and it's not necessarily+a good idea to force types on the way in to SimplCont, because they+may end up not being used and forcing them could be a lot of wasted+work. T5631 is a good example of this.++- For ApplyToTy's sc_arg_ty, we force the type on the way in because+ the type will almost certainly appear as a type argument in the+ output program.++- For the hole types in Stop and ApplyToTy, we force the type when we+ emit it into the output program, after obtaining it from+ contResultType. (The hole type in ApplyToTy is only directly used+ to form the result type in a new Stop continuation.)+-}++---------------------------------+-- Simplify a join point, adding the context.+-- Context goes *inside* the lambdas. IOW, if the join point has arity n, we do:+-- \x1 .. xn -> e => \x1 .. xn -> E[e]+-- Note that we need the arity of the join point, since e may be a lambda+-- (though this is unlikely). See Note [Case-of-case and join points].+simplJoinRhs :: SimplEnv -> InId -> InExpr -> SimplCont+ -> SimplM OutExpr+simplJoinRhs env bndr expr cont+ | Just arity <- isJoinId_maybe bndr+ = do { let (join_bndrs, join_body) = collectNBinders arity expr+ ; (env', join_bndrs') <- simplLamBndrs env join_bndrs+ ; join_body' <- simplExprC env' join_body cont+ ; return $ mkLams join_bndrs' join_body' }++ | otherwise+ = pprPanic "simplJoinRhs" (ppr bndr)++---------------------------------+simplType :: SimplEnv -> InType -> SimplM OutType+ -- Kept monadic just so we can do the seqType+ -- See Note [Avoiding space leaks in OutType]+simplType env ty+ = -- pprTrace "simplType" (ppr ty $$ ppr (seTvSubst env)) $+ seqType new_ty `seq` return new_ty+ where+ new_ty = substTy env ty++---------------------------------+simplCoercionF :: SimplEnv -> InCoercion -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+simplCoercionF env co cont+ = do { co' <- simplCoercion env co+ ; rebuild env (Coercion co') cont }++simplCoercion :: SimplEnv -> InCoercion -> SimplM OutCoercion+simplCoercion env co+ = let opt_co = optCoercion (getTCvSubst env) co+ in seqCo opt_co `seq` return opt_co++-----------------------------------+-- | Push a TickIt context outwards past applications and cases, as+-- long as this is a non-scoping tick, to let case and application+-- optimisations apply.++simplTick :: SimplEnv -> Tickish Id -> InExpr -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+simplTick env tickish expr cont+ -- A scoped tick turns into a continuation, so that we can spot+ -- (scc t (\x . e)) in simplLam and eliminate the scc. If we didn't do+ -- it this way, then it would take two passes of the simplifier to+ -- reduce ((scc t (\x . e)) e').+ -- NB, don't do this with counting ticks, because if the expr is+ -- bottom, then rebuildCall will discard the continuation.++-- XXX: we cannot do this, because the simplifier assumes that+-- the context can be pushed into a case with a single branch. e.g.+-- scc<f> case expensive of p -> e+-- becomes+-- case expensive of p -> scc<f> e+--+-- So I'm disabling this for now. It just means we will do more+-- simplifier iterations that necessary in some cases.++-- | tickishScoped tickish && not (tickishCounts tickish)+-- = simplExprF env expr (TickIt tickish cont)++ -- For unscoped or soft-scoped ticks, we are allowed to float in new+ -- cost, so we simply push the continuation inside the tick. This+ -- has the effect of moving the tick to the outside of a case or+ -- application context, allowing the normal case and application+ -- optimisations to fire.+ | tickish `tickishScopesLike` SoftScope+ = do { (floats, expr') <- simplExprF env expr cont+ ; return (floats, mkTick tickish expr')+ }++ -- Push tick inside if the context looks like this will allow us to+ -- do a case-of-case - see Note [case-of-scc-of-case]+ | Select {} <- cont, Just expr' <- push_tick_inside+ = simplExprF env expr' cont++ -- We don't want to move the tick, but we might still want to allow+ -- floats to pass through with appropriate wrapping (or not, see+ -- wrap_floats below)+ --- | not (tickishCounts tickish) || tickishCanSplit tickish+ -- = wrap_floats++ | otherwise+ = no_floating_past_tick++ where++ -- Try to push tick inside a case, see Note [case-of-scc-of-case].+ push_tick_inside =+ case expr0 of+ Case scrut bndr ty alts+ -> Just $ Case (tickScrut scrut) bndr ty (map tickAlt alts)+ _other -> Nothing+ where (ticks, expr0) = stripTicksTop movable (Tick tickish expr)+ movable t = not (tickishCounts t) ||+ t `tickishScopesLike` NoScope ||+ tickishCanSplit t+ tickScrut e = foldr mkTick e ticks+ -- Alternatives get annotated with all ticks that scope in some way,+ -- but we don't want to count entries.+ tickAlt (c,bs,e) = (c,bs, foldr mkTick e ts_scope)+ ts_scope = map mkNoCount $+ filter (not . (`tickishScopesLike` NoScope)) ticks++ no_floating_past_tick =+ do { let (inc,outc) = splitCont cont+ ; (floats, expr1) <- simplExprF env expr inc+ ; let expr2 = wrapFloats floats expr1+ tickish' = simplTickish env tickish+ ; rebuild env (mkTick tickish' expr2) outc+ }++-- Alternative version that wraps outgoing floats with the tick. This+-- results in ticks being duplicated, as we don't make any attempt to+-- eliminate the tick if we re-inline the binding (because the tick+-- semantics allows unrestricted inlining of HNFs), so I'm not doing+-- this any more. FloatOut will catch any real opportunities for+-- floating.+--+-- wrap_floats =+-- do { let (inc,outc) = splitCont cont+-- ; (env', expr') <- simplExprF (zapFloats env) expr inc+-- ; let tickish' = simplTickish env tickish+-- ; let wrap_float (b,rhs) = (zapIdStrictness (setIdArity b 0),+-- mkTick (mkNoCount tickish') rhs)+-- -- when wrapping a float with mkTick, we better zap the Id's+-- -- strictness info and arity, because it might be wrong now.+-- ; let env'' = addFloats env (mapFloats env' wrap_float)+-- ; rebuild env'' expr' (TickIt tickish' outc)+-- }+++ simplTickish env tickish+ | Breakpoint n ids <- tickish+ = Breakpoint n (map (getDoneId . substId env) ids)+ | otherwise = tickish++ -- Push type application and coercion inside a tick+ splitCont :: SimplCont -> (SimplCont, SimplCont)+ splitCont cont@(ApplyToTy { sc_cont = tail }) = (cont { sc_cont = inc }, outc)+ where (inc,outc) = splitCont tail+ splitCont (CastIt co c) = (CastIt co inc, outc)+ where (inc,outc) = splitCont c+ splitCont other = (mkBoringStop (contHoleType other), other)++ getDoneId (DoneId id) = id+ getDoneId (DoneEx e _) = getIdFromTrivialExpr e -- Note [substTickish] in CoreSubst+ getDoneId other = pprPanic "getDoneId" (ppr other)++-- Note [case-of-scc-of-case]+-- It's pretty important to be able to transform case-of-case when+-- there's an SCC in the way. For example, the following comes up+-- in nofib/real/compress/Encode.hs:+--+-- case scctick<code_string.r1>+-- case $wcode_string_r13s wild_XC w1_s137 w2_s138 l_aje+-- of _ { (# ww1_s13f, ww2_s13g, ww3_s13h #) ->+-- (ww1_s13f, ww2_s13g, ww3_s13h)+-- }+-- of _ { (ww_s12Y, ww1_s12Z, ww2_s130) ->+-- tick<code_string.f1>+-- (ww_s12Y,+-- ww1_s12Z,+-- PTTrees.PT+-- @ GHC.Types.Char @ GHC.Types.Int wild2_Xj ww2_s130 r_ajf)+-- }+--+-- We really want this case-of-case to fire, because then the 3-tuple+-- will go away (indeed, the CPR optimisation is relying on this+-- happening). But the scctick is in the way - we need to push it+-- inside to expose the case-of-case. So we perform this+-- transformation on the inner case:+--+-- scctick c (case e of { p1 -> e1; ...; pn -> en })+-- ==>+-- case (scctick c e) of { p1 -> scc c e1; ...; pn -> scc c en }+--+-- So we've moved a constant amount of work out of the scc to expose+-- the case. We only do this when the continuation is interesting: in+-- for now, it has to be another Case (maybe generalise this later).++{-+************************************************************************+* *+\subsection{The main rebuilder}+* *+************************************************************************+-}++rebuild :: SimplEnv -> OutExpr -> SimplCont -> SimplM (SimplFloats, OutExpr)+-- At this point the substitution in the SimplEnv should be irrelevant;+-- only the in-scope set matters+rebuild env expr cont+ = case cont of+ Stop {} -> return (emptyFloats env, expr)+ TickIt t cont -> rebuild env (mkTick t expr) cont+ CastIt co cont -> rebuild env (mkCast expr co) cont+ -- NB: mkCast implements the (Coercion co |> g) optimisation++ Select { sc_bndr = bndr, sc_alts = alts, sc_env = se, sc_cont = cont }+ -> rebuildCase (se `setInScopeFromE` env) expr bndr alts cont++ StrictArg { sc_fun = fun, sc_cont = cont }+ -> rebuildCall env (fun `addValArgTo` expr) cont+ StrictBind { sc_bndr = b, sc_bndrs = bs, sc_body = body+ , sc_env = se, sc_cont = cont }+ -> do { (floats1, env') <- simplNonRecX (se `setInScopeFromE` env) b expr+ -- expr satisfies let/app since it started life+ -- in a call to simplNonRecE+ ; (floats2, expr') <- simplLam env' bs body cont+ ; return (floats1 `addFloats` floats2, expr') }++ ApplyToTy { sc_arg_ty = ty, sc_cont = cont}+ -> rebuild env (App expr (Type ty)) cont++ ApplyToVal { sc_arg = arg, sc_env = se, sc_dup = dup_flag, sc_cont = cont}+ -- See Note [Avoid redundant simplification]+ -> do { (_, _, arg') <- simplArg env dup_flag se arg+ ; rebuild env (App expr arg') cont }++{-+************************************************************************+* *+\subsection{Lambdas}+* *+************************************************************************+-}++simplCast :: SimplEnv -> InExpr -> Coercion -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+simplCast env body co0 cont0+ = do { co1 <- simplCoercion env co0+ ; cont1 <- addCoerce co1 cont0+ ; simplExprF env body cont1 }+ where+ addCoerce :: OutCoercion -> SimplCont -> SimplM SimplCont+ addCoerce co1 (CastIt co2 cont)+ = addCoerce (mkTransCo co1 co2) cont++ addCoerce co cont@(ApplyToTy { sc_arg_ty = arg_ty, sc_cont = tail })+ | Just (arg_ty', co') <- pushCoTyArg co arg_ty+ = do { tail' <- addCoerce co' tail+ ; return (cont { sc_arg_ty = arg_ty', sc_cont = tail' }) }++ addCoerce co cont@(ApplyToVal { sc_arg = arg, sc_env = arg_se+ , sc_dup = dup, sc_cont = tail })+ | Just (co1, co2) <- pushCoValArg co+ , Pair _ new_ty <- coercionKind co1+ , not (isTypeLevPoly new_ty) -- without this check, we get a lev-poly arg+ -- See Note [Levity polymorphism invariants] in CoreSyn+ -- test: typecheck/should_run/EtaExpandLevPoly+ = do { tail' <- addCoerce co2 tail+ ; if isReflCo co1+ then return (cont { sc_cont = tail' })+ -- Avoid simplifying if possible;+ -- See Note [Avoiding exponential behaviour]+ else do+ { (dup', arg_se', arg') <- simplArg env dup arg_se arg+ -- When we build the ApplyTo we can't mix the OutCoercion+ -- 'co' with the InExpr 'arg', so we simplify+ -- to make it all consistent. It's a bit messy.+ -- But it isn't a common case.+ -- Example of use: Trac #995+ ; return (ApplyToVal { sc_arg = mkCast arg' co1+ , sc_env = arg_se'+ , sc_dup = dup'+ , sc_cont = tail' }) } }++ addCoerce co cont+ | isReflexiveCo co = return cont+ | otherwise = return (CastIt co cont)+ -- It's worth checking isReflexiveCo.+ -- For example, in the initial form of a worker+ -- we may find (coerce T (coerce S (\x.e))) y+ -- and we'd like it to simplify to e[y/x] in one round+ -- of simplification++simplArg :: SimplEnv -> DupFlag -> StaticEnv -> CoreExpr+ -> SimplM (DupFlag, StaticEnv, OutExpr)+simplArg env dup_flag arg_env arg+ | isSimplified dup_flag+ = return (dup_flag, arg_env, arg)+ | otherwise+ = do { arg' <- simplExpr (arg_env `setInScopeFromE` env) arg+ ; return (Simplified, zapSubstEnv arg_env, arg') }++{-+************************************************************************+* *+\subsection{Lambdas}+* *+************************************************************************+-}++simplLam :: SimplEnv -> [InId] -> InExpr -> SimplCont+ -> SimplM (SimplFloats, OutExpr)++simplLam env [] body cont+ = simplExprF env body cont++simplLam env (bndr:bndrs) body (ApplyToTy { sc_arg_ty = arg_ty, sc_cont = cont })+ = do { tick (BetaReduction bndr)+ ; simplLam (extendTvSubst env bndr arg_ty) bndrs body cont }++simplLam env (bndr:bndrs) body (ApplyToVal { sc_arg = arg, sc_env = arg_se+ , sc_cont = cont, sc_dup = dup })+ | isSimplified dup -- Don't re-simplify if we've simplified it once+ -- See Note [Avoiding exponential behaviour]+ = do { tick (BetaReduction bndr)+ ; (floats1, env') <- simplNonRecX env zapped_bndr arg+ ; (floats2, expr') <- simplLam env' bndrs body cont+ ; return (floats1 `addFloats` floats2, expr') }++ | otherwise+ = do { tick (BetaReduction bndr)+ ; simplNonRecE env zapped_bndr (arg, arg_se) (bndrs, body) cont }+ where+ zapped_bndr -- See Note [Zap unfolding when beta-reducing]+ | isId bndr = zapStableUnfolding bndr+ | otherwise = bndr++ -- Discard a non-counting tick on a lambda. This may change the+ -- cost attribution slightly (moving the allocation of the+ -- lambda elsewhere), but we don't care: optimisation changes+ -- cost attribution all the time.+simplLam env bndrs body (TickIt tickish cont)+ | not (tickishCounts tickish)+ = simplLam env bndrs body cont++ -- Not enough args, so there are real lambdas left to put in the result+simplLam env bndrs body cont+ = do { (env', bndrs') <- simplLamBndrs env bndrs+ ; body' <- simplExpr env' body+ ; new_lam <- mkLam env bndrs' body' cont+ ; rebuild env' new_lam cont }++-------------+simplLamBndr :: SimplEnv -> InBndr -> SimplM (SimplEnv, OutBndr)+-- Used for lambda binders. These sometimes have unfoldings added by+-- the worker/wrapper pass that must be preserved, because they can't+-- be reconstructed from context. For example:+-- f x = case x of (a,b) -> fw a b x+-- fw a b x{=(a,b)} = ...+-- The "{=(a,b)}" is an unfolding we can't reconstruct otherwise.+simplLamBndr env bndr+ | isId bndr && isFragileUnfolding old_unf -- Special case+ = do { (env1, bndr1) <- simplBinder env bndr+ ; unf' <- simplStableUnfolding env1 NotTopLevel Nothing bndr old_unf+ ; let bndr2 = bndr1 `setIdUnfolding` unf'+ ; return (modifyInScope env1 bndr2, bndr2) }++ | otherwise+ = simplBinder env bndr -- Normal case+ where+ old_unf = idUnfolding bndr++simplLamBndrs :: SimplEnv -> [InBndr] -> SimplM (SimplEnv, [OutBndr])+simplLamBndrs env bndrs = mapAccumLM simplLamBndr env bndrs++------------------+simplNonRecE :: SimplEnv+ -> InId -- The binder, always an Id+ -- Never a join point+ -> (InExpr, SimplEnv) -- Rhs of binding (or arg of lambda)+ -> ([InBndr], InExpr) -- Body of the let/lambda+ -- \xs.e+ -> SimplCont+ -> SimplM (SimplFloats, OutExpr)++-- simplNonRecE is used for+-- * non-top-level non-recursive non-join-point lets in expressions+-- * beta reduction+--+-- simplNonRec env b (rhs, rhs_se) (bs, body) k+-- = let env in+-- cont< let b = rhs_se(rhs) in \bs.body >+--+-- It deals with strict bindings, via the StrictBind continuation,+-- which may abort the whole process+--+-- Precondition: rhs satisfies the let/app invariant+-- Note [CoreSyn let/app invariant] in CoreSyn+--+-- The "body" of the binding comes as a pair of ([InId],InExpr)+-- representing a lambda; so we recurse back to simplLam+-- Why? Because of the binder-occ-info-zapping done before+-- the call to simplLam in simplExprF (Lam ...)++simplNonRecE env bndr (rhs, rhs_se) (bndrs, body) cont+ | ASSERT( isId bndr && not (isJoinId bndr) )+ preInlineUnconditionally env NotTopLevel bndr rhs+ = do { tick (PreInlineUnconditionally bndr)+ ; -- pprTrace "preInlineUncond" (ppr bndr <+> ppr rhs) $+ simplLam (extendIdSubst env bndr (mkContEx rhs_se rhs)) bndrs body cont }++ -- Deal with strict bindings+ | isStrictId bndr -- Includes coercions+ , sm_case_case (getMode env)+ = simplExprF (rhs_se `setInScopeFromE` env) rhs+ (StrictBind { sc_bndr = bndr, sc_bndrs = bndrs, sc_body = body+ , sc_env = env, sc_cont = cont, sc_dup = NoDup })++ -- Deal with lazy bindings+ | otherwise+ = ASSERT( not (isTyVar bndr) )+ do { (env1, bndr1) <- simplNonRecBndr env bndr+ ; (env2, bndr2) <- addBndrRules env1 bndr bndr1+ ; (floats1, env3) <- simplLazyBind env2 NotTopLevel NonRecursive bndr bndr2 rhs rhs_se+ ; (floats2, expr') <- simplLam env3 bndrs body cont+ ; return (floats1 `addFloats` floats2, expr') }++------------------+simplRecE :: SimplEnv+ -> [(InId, InExpr)]+ -> InExpr+ -> SimplCont+ -> SimplM (SimplFloats, OutExpr)++-- simplRecE is used for+-- * non-top-level recursive lets in expressions+simplRecE env pairs body cont+ = do { let bndrs = map fst pairs+ ; MASSERT(all (not . isJoinId) bndrs)+ ; env1 <- simplRecBndrs env bndrs+ -- NB: bndrs' don't have unfoldings or rules+ -- We add them as we go down+ ; (floats1, env2) <- simplRecBind env1 NotTopLevel Nothing pairs+ ; (floats2, expr') <- simplExprF env2 body cont+ ; return (floats1 `addFloats` floats2, expr') }++{- Note [Avoiding exponential behaviour]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+One way in which we can get exponential behaviour is if we simplify a+big expression, and the re-simplify it -- and then this happens in a+deeply-nested way. So we must be jolly careful about re-simplifying+an expression. That is why completeNonRecX does not try+preInlineUnconditionally.++Example:+ f BIG, where f has a RULE+Then+ * We simplify BIG before trying the rule; but the rule does not fire+ * We inline f = \x. x True+ * So if we did preInlineUnconditionally we'd re-simplify (BIG True)++However, if BIG has /not/ already been simplified, we'd /like/ to+simplify BIG True; maybe good things happen. That is why++* simplLam has+ - a case for (isSimplified dup), which goes via simplNonRecX, and+ - a case for the un-simplified case, which goes via simplNonRecE++* We go to some efforts to avoid unnecessarily simplifying ApplyToVal,+ in at least two places+ - In simplCast/addCoerce, where we check for isReflCo+ - In rebuildCall we avoid simplifying arguments before we have to+ (see Note [Trying rewrite rules])+++Note [Zap unfolding when beta-reducing]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Lambda-bound variables can have stable unfoldings, such as+ $j = \x. \b{Unf=Just x}. e+See Note [Case binders and join points] below; the unfolding for lets+us optimise e better. However when we beta-reduce it we want to+revert to using the actual value, otherwise we can end up in the+stupid situation of+ let x = blah in+ let b{Unf=Just x} = y+ in ...b...+Here it'd be far better to drop the unfolding and use the actual RHS.++************************************************************************+* *+ Join points+* *+********************************************************************* -}++simplNonRecJoinPoint :: SimplEnv -> InId -> InExpr+ -> InExpr -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+simplNonRecJoinPoint env bndr rhs body cont+ | ASSERT( isJoinId bndr )+ preInlineUnconditionally env NotTopLevel bndr rhs+ = do { tick (PreInlineUnconditionally bndr)+ ; simplExprF (extendIdSubst env bndr (mkContEx env rhs)) body cont }++ | otherwise+ = wrapJoinCont env cont $ \ env cont ->+ do { -- We push join_cont into the join RHS and the body;+ -- and wrap wrap_cont around the whole thing+ ; let res_ty = contResultType cont+ ; (env1, bndr1) <- simplNonRecJoinBndr env res_ty bndr+ ; (env2, bndr2) <- addBndrRules env1 bndr bndr1+ ; (floats1, env3) <- simplJoinBind env2 cont bndr bndr2 rhs env+ ; (floats2, body') <- simplExprF env3 body cont+ ; return (floats1 `addFloats` floats2, body') }+++------------------+simplRecJoinPoint :: SimplEnv -> [(InId, InExpr)]+ -> InExpr -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+simplRecJoinPoint env pairs body cont+ = wrapJoinCont env cont $ \ env cont ->+ do { let bndrs = map fst pairs+ res_ty = contResultType cont+ ; env1 <- simplRecJoinBndrs env res_ty bndrs+ -- NB: bndrs' don't have unfoldings or rules+ -- We add them as we go down+ ; (floats1, env2) <- simplRecBind env1 NotTopLevel (Just cont) pairs+ ; (floats2, body') <- simplExprF env2 body cont+ ; return (floats1 `addFloats` floats2, body') }++--------------------+wrapJoinCont :: SimplEnv -> SimplCont+ -> (SimplEnv -> SimplCont -> SimplM (SimplFloats, OutExpr))+ -> SimplM (SimplFloats, OutExpr)+-- Deal with making the continuation duplicable if necessary,+-- and with the no-case-of-case situation.+wrapJoinCont env cont thing_inside+ | contIsStop cont -- Common case; no need for fancy footwork+ = thing_inside env cont++ | not (sm_case_case (getMode env))+ -- See Note [Join points wih -fno-case-of-case]+ = do { (floats1, expr1) <- thing_inside env (mkBoringStop (contHoleType cont))+ ; let (floats2, expr2) = wrapJoinFloatsX floats1 expr1+ ; (floats3, expr3) <- rebuild (env `setInScopeFromF` floats2) expr2 cont+ ; return (floats2 `addFloats` floats3, expr3) }++ | otherwise+ -- Normal case; see Note [Join points and case-of-case]+ = do { (floats1, cont') <- mkDupableCont env cont+ ; (floats2, result) <- thing_inside (env `setInScopeFromF` floats1) cont'+ ; return (floats1 `addFloats` floats2, result) }+++--------------------+trimJoinCont :: Id -> Maybe JoinArity -> SimplCont -> SimplCont+-- Drop outer context from join point invocation (jump)+-- See Note [Join points and case-of-case]++trimJoinCont _ Nothing cont+ = cont -- Not a jump+trimJoinCont var (Just arity) cont+ = trim arity cont+ where+ trim 0 cont@(Stop {})+ = cont+ trim 0 cont+ = mkBoringStop (contResultType cont)+ trim n cont@(ApplyToVal { sc_cont = k })+ = cont { sc_cont = trim (n-1) k }+ trim n cont@(ApplyToTy { sc_cont = k })+ = cont { sc_cont = trim (n-1) k } -- join arity counts types!+ trim _ cont+ = pprPanic "completeCall" $ ppr var $$ ppr cont+++{- Note [Join points and case-of-case]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we perform the case-of-case transform (or otherwise push continuations+inward), we want to treat join points specially. Since they're always+tail-called and we want to maintain this invariant, we can do this (for any+evaluation context E):++ E[join j = e+ in case ... of+ A -> jump j 1+ B -> jump j 2+ C -> f 3]++ -->++ join j = E[e]+ in case ... of+ A -> jump j 1+ B -> jump j 2+ C -> E[f 3]++As is evident from the example, there are two components to this behavior:++ 1. When entering the RHS of a join point, copy the context inside.+ 2. When a join point is invoked, discard the outer context.++We need to be very careful here to remain consistent---neither part is+optional!++We need do make the continuation E duplicable (since we are duplicating it)+with mkDuableCont.+++Note [Join points wih -fno-case-of-case]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Supose case-of-case is switched off, and we are simplifying++ case (join j x = <j-rhs> in+ case y of+ A -> j 1+ B -> j 2+ C -> e) of <outer-alts>++Usually, we'd push the outer continuation (case . of <outer-alts>) into+both the RHS and the body of the join point j. But since we aren't doing+case-of-case we may then end up with this totally bogus result++ join x = case <j-rhs> of <outer-alts> in+ case (case y of+ A -> j 1+ B -> j 2+ C -> e) of <outer-alts>++This would be OK in the language of the paper, but not in GHC: j is no longer+a join point. We can only do the "push contination into the RHS of the+join point j" if we also push the contination right down to the /jumps/ to+j, so that it can evaporate there. If we are doing case-of-case, we'll get to++ join x = case <j-rhs> of <outer-alts> in+ case y of+ A -> j 1+ B -> j 2+ C -> case e of <outer-alts>++which is great.++Bottom line: if case-of-case is off, we must stop pushing the continuation+inwards altogether at any join point. Instead simplify the (join ... in ...)+with a Stop continuation, and wrap the original continuation around the+outside. Surprisingly tricky!+++************************************************************************+* *+ Variables+* *+************************************************************************+-}++simplVar :: SimplEnv -> InVar -> SimplM OutExpr+-- Look up an InVar in the environment+simplVar env var+ | isTyVar var = return (Type (substTyVar env var))+ | isCoVar var = return (Coercion (substCoVar env var))+ | otherwise+ = case substId env var of+ ContEx tvs cvs ids e -> simplExpr (setSubstEnv env tvs cvs ids) e+ DoneId var1 -> return (Var var1)+ DoneEx e _ -> return e++simplIdF :: SimplEnv -> InId -> SimplCont -> SimplM (SimplFloats, OutExpr)+simplIdF env var cont+ = case substId env var of+ ContEx tvs cvs ids e -> simplExprF (setSubstEnv env tvs cvs ids) e cont+ -- Don't trim; haven't already simplified e,+ -- so the cont is not embodied in e++ DoneId var1 -> completeCall env var1 (trimJoinCont var (isJoinId_maybe var1) cont)++ DoneEx e mb_join -> simplExprF (zapSubstEnv env) e (trimJoinCont var mb_join cont)+ -- Note [zapSubstEnv]+ -- The template is already simplified, so don't re-substitute.+ -- This is VITAL. Consider+ -- let x = e in+ -- let y = \z -> ...x... in+ -- \ x -> ...y...+ -- We'll clone the inner \x, adding x->x' in the id_subst+ -- Then when we inline y, we must *not* replace x by x' in+ -- the inlined copy!!++---------------------------------------------------------+-- Dealing with a call site++completeCall :: SimplEnv -> OutId -> SimplCont -> SimplM (SimplFloats, OutExpr)+completeCall env var cont+ | Just expr <- callSiteInline dflags var unfolding+ lone_variable arg_infos interesting_cont+ -- Inline the variable's RHS+ = do { checkedTick (UnfoldingDone var)+ ; dump_inline expr cont+ ; simplExprF (zapSubstEnv env) expr cont }++ | otherwise+ -- Don't inline; instead rebuild the call+ = do { rule_base <- getSimplRules+ ; let info = mkArgInfo var (getRules rule_base var)+ n_val_args call_cont+ ; rebuildCall env info cont }++ where+ dflags = seDynFlags env+ (lone_variable, arg_infos, call_cont) = contArgs cont+ n_val_args = length arg_infos+ interesting_cont = interestingCallContext env call_cont+ unfolding = activeUnfolding env var++ dump_inline unfolding cont+ | not (dopt Opt_D_dump_inlinings dflags) = return ()+ | not (dopt Opt_D_verbose_core2core dflags)+ = when (isExternalName (idName var)) $+ liftIO $ printOutputForUser dflags alwaysQualify $+ sep [text "Inlining done:", nest 4 (ppr var)]+ | otherwise+ = liftIO $ printOutputForUser dflags alwaysQualify $+ sep [text "Inlining done: " <> ppr var,+ nest 4 (vcat [text "Inlined fn: " <+> nest 2 (ppr unfolding),+ text "Cont: " <+> ppr cont])]++rebuildCall :: SimplEnv+ -> ArgInfo+ -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+-- We decided not to inline, so+-- - simplify the arguments+-- - try rewrite rules+-- - and rebuild++---------- Bottoming applications --------------+rebuildCall env (ArgInfo { ai_fun = fun, ai_args = rev_args, ai_strs = [] }) cont+ -- When we run out of strictness args, it means+ -- that the call is definitely bottom; see SimplUtils.mkArgInfo+ -- Then we want to discard the entire strict continuation. E.g.+ -- * case (error "hello") of { ... }+ -- * (error "Hello") arg+ -- * f (error "Hello") where f is strict+ -- etc+ -- Then, especially in the first of these cases, we'd like to discard+ -- the continuation, leaving just the bottoming expression. But the+ -- type might not be right, so we may have to add a coerce.+ | not (contIsTrivial cont) -- Only do this if there is a non-trivial+ -- continuation to discard, else we do it+ -- again and again!+ = seqType cont_ty `seq` -- See Note [Avoiding space leaks in OutType]+ return (emptyFloats env, castBottomExpr res cont_ty)+ where+ res = argInfoExpr fun rev_args+ cont_ty = contResultType cont++---------- Try rewrite RULES --------------+-- See Note [Trying rewrite rules]+rebuildCall env info@(ArgInfo { ai_fun = fun, ai_args = rev_args+ , ai_rules = Just (nr_wanted, rules) }) cont+ | nr_wanted == 0 || no_more_args+ , let info' = info { ai_rules = Nothing }+ = -- We've accumulated a simplified call in <fun,rev_args>+ -- so try rewrite rules; see Note [RULEs apply to simplified arguments]+ -- See also Note [Rules for recursive functions]+ do { mb_match <- tryRules env rules fun (reverse rev_args) cont+ ; case mb_match of+ Just (env', rhs, cont') -> simplExprF env' rhs cont'+ Nothing -> rebuildCall env info' cont }+ where+ no_more_args = case cont of+ ApplyToTy {} -> False+ ApplyToVal {} -> False+ _ -> True+++---------- Simplify applications and casts --------------+rebuildCall env info (CastIt co cont)+ = rebuildCall env (addCastTo info co) cont++rebuildCall env info (ApplyToTy { sc_arg_ty = arg_ty, sc_cont = cont })+ = rebuildCall env (addTyArgTo info arg_ty) cont++rebuildCall env info@(ArgInfo { ai_encl = encl_rules, ai_type = fun_ty+ , ai_strs = str:strs, ai_discs = disc:discs })+ (ApplyToVal { sc_arg = arg, sc_env = arg_se+ , sc_dup = dup_flag, sc_cont = cont })+ | isSimplified dup_flag -- See Note [Avoid redundant simplification]+ = rebuildCall env (addValArgTo info' arg) cont++ | str -- Strict argument+ , sm_case_case (getMode env)+ = -- pprTrace "Strict Arg" (ppr arg $$ ppr (seIdSubst env) $$ ppr (seInScope env)) $+ simplExprF (arg_se `setInScopeFromE` env) arg+ (StrictArg { sc_fun = info', sc_cci = cci_strict+ , sc_dup = Simplified, sc_cont = cont })+ -- Note [Shadowing]++ | otherwise -- Lazy argument+ -- DO NOT float anything outside, hence simplExprC+ -- There is no benefit (unlike in a let-binding), and we'd+ -- have to be very careful about bogus strictness through+ -- floating a demanded let.+ = do { arg' <- simplExprC (arg_se `setInScopeFromE` env) arg+ (mkLazyArgStop arg_ty cci_lazy)+ ; rebuildCall env (addValArgTo info' arg') cont }+ where+ info' = info { ai_strs = strs, ai_discs = discs }+ arg_ty = funArgTy fun_ty++ -- Use this for lazy arguments+ cci_lazy | encl_rules = RuleArgCtxt+ | disc > 0 = DiscArgCtxt -- Be keener here+ | otherwise = BoringCtxt -- Nothing interesting++ -- ..and this for strict arguments+ cci_strict | encl_rules = RuleArgCtxt+ | disc > 0 = DiscArgCtxt+ | otherwise = RhsCtxt+ -- Why RhsCtxt? if we see f (g x) (h x), and f is strict, we+ -- want to be a bit more eager to inline g, because it may+ -- expose an eval (on x perhaps) that can be eliminated or+ -- shared. I saw this in nofib 'boyer2', RewriteFuns.onewayunify1+ -- It's worth an 18% improvement in allocation for this+ -- particular benchmark; 5% on 'mate' and 1.3% on 'multiplier'++---------- No further useful info, revert to generic rebuild ------------+rebuildCall env (ArgInfo { ai_fun = fun, ai_args = rev_args }) cont+ = rebuild env (argInfoExpr fun rev_args) cont++{- Note [Trying rewrite rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider an application (f e1 e2 e3) where the e1,e2,e3 are not yet+simplified. We want to simplify enough arguments to allow the rules+to apply, but it's more efficient to avoid simplifying e2,e3 if e1 alone+is sufficient. Example: class ops+ (+) dNumInt e2 e3+If we rewrite ((+) dNumInt) to plusInt, we can take advantage of the+latter's strictness when simplifying e2, e3. Moreover, suppose we have+ RULE f Int = \x. x True++Then given (f Int e1) we rewrite to+ (\x. x True) e1+without simplifying e1. Now we can inline x into its unique call site,+and absorb the True into it all in the same pass. If we simplified+e1 first, we couldn't do that; see Note [Avoiding exponential behaviour].++So we try to apply rules if either+ (a) no_more_args: we've run out of argument that the rules can "see"+ (b) nr_wanted: none of the rules wants any more arguments+++Note [RULES apply to simplified arguments]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's very desirable to try RULES once the arguments have been simplified, because+doing so ensures that rule cascades work in one pass. Consider+ {-# RULES g (h x) = k x+ f (k x) = x #-}+ ...f (g (h x))...+Then we want to rewrite (g (h x)) to (k x) and only then try f's rules. If+we match f's rules against the un-simplified RHS, it won't match. This+makes a particularly big difference when superclass selectors are involved:+ op ($p1 ($p2 (df d)))+We want all this to unravel in one sweep.++Note [Avoid redundant simplification]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Because RULES apply to simplified arguments, there's a danger of repeatedly+simplifying already-simplified arguments. An important example is that of+ (>>=) d e1 e2+Here e1, e2 are simplified before the rule is applied, but don't really+participate in the rule firing. So we mark them as Simplified to avoid+re-simplifying them.++Note [Shadowing]+~~~~~~~~~~~~~~~~+This part of the simplifier may break the no-shadowing invariant+Consider+ f (...(\a -> e)...) (case y of (a,b) -> e')+where f is strict in its second arg+If we simplify the innermost one first we get (...(\a -> e)...)+Simplifying the second arg makes us float the case out, so we end up with+ case y of (a,b) -> f (...(\a -> e)...) e'+So the output does not have the no-shadowing invariant. However, there is+no danger of getting name-capture, because when the first arg was simplified+we used an in-scope set that at least mentioned all the variables free in its+static environment, and that is enough.++We can't just do innermost first, or we'd end up with a dual problem:+ case x of (a,b) -> f e (...(\a -> e')...)++I spent hours trying to recover the no-shadowing invariant, but I just could+not think of an elegant way to do it. The simplifier is already knee-deep in+continuations. We have to keep the right in-scope set around; AND we have+to get the effect that finding (error "foo") in a strict arg position will+discard the entire application and replace it with (error "foo"). Getting+all this at once is TOO HARD!+++************************************************************************+* *+ Rewrite rules+* *+************************************************************************+-}++tryRules :: SimplEnv -> [CoreRule]+ -> Id -> [ArgSpec]+ -> SimplCont+ -> SimplM (Maybe (SimplEnv, CoreExpr, SimplCont))++tryRules env rules fn args call_cont+ | null rules+ = return Nothing++{- Disabled until we fix #8326+ | fn `hasKey` tagToEnumKey -- See Note [Optimising tagToEnum#]+ , [_type_arg, val_arg] <- args+ , Select dup bndr ((_,[],rhs1) : rest_alts) se cont <- call_cont+ , isDeadBinder bndr+ = do { let enum_to_tag :: CoreAlt -> CoreAlt+ -- Takes K -> e into tagK# -> e+ -- where tagK# is the tag of constructor K+ enum_to_tag (DataAlt con, [], rhs)+ = ASSERT( isEnumerationTyCon (dataConTyCon con) )+ (LitAlt tag, [], rhs)+ where+ tag = mkMachInt dflags (toInteger (dataConTag con - fIRST_TAG))+ enum_to_tag alt = pprPanic "tryRules: tagToEnum" (ppr alt)++ new_alts = (DEFAULT, [], rhs1) : map enum_to_tag rest_alts+ new_bndr = setIdType bndr intPrimTy+ -- The binder is dead, but should have the right type+ ; return (Just (val_arg, Select dup new_bndr new_alts se cont)) }+-}++ | Just (rule, rule_rhs) <- lookupRule dflags (getUnfoldingInRuleMatch env)+ (activeRule env) fn+ (argInfoAppArgs args) rules+ -- Fire a rule for the function+ = do { checkedTick (RuleFired (ruleName rule))+ ; let cont' = pushSimplifiedArgs zapped_env+ (drop (ruleArity rule) args)+ call_cont+ -- (ruleArity rule) says how+ -- many args the rule consumed++ occ_anald_rhs = occurAnalyseExpr rule_rhs+ -- See Note [Occurrence-analyse after rule firing]+ ; dump rule rule_rhs+ ; return (Just (zapped_env, occ_anald_rhs, cont')) }+ -- The occ_anald_rhs and cont' are all Out things+ -- hence zapping the environment++ | otherwise -- No rule fires+ = do { nodump -- This ensures that an empty file is written+ ; return Nothing }++ where+ dflags = seDynFlags env+ zapped_env = zapSubstEnv env -- See Note [zapSubstEnv]++ printRuleModule rule+ = parens (maybe (text "BUILTIN")+ (pprModuleName . moduleName)+ (ruleModule rule))++ dump rule rule_rhs+ | dopt Opt_D_dump_rule_rewrites dflags+ = log_rule dflags Opt_D_dump_rule_rewrites "Rule fired" $ vcat+ [ text "Rule:" <+> ftext (ruleName rule)+ , text "Module:" <+> printRuleModule rule+ , text "Before:" <+> hang (ppr fn) 2 (sep (map ppr args))+ , text "After: " <+> pprCoreExpr rule_rhs+ , text "Cont: " <+> ppr call_cont ]++ | dopt Opt_D_dump_rule_firings dflags+ = log_rule dflags Opt_D_dump_rule_firings "Rule fired:" $+ ftext (ruleName rule)+ <+> printRuleModule rule++ | otherwise+ = return ()++ nodump+ | dopt Opt_D_dump_rule_rewrites dflags+ = liftIO $ dumpSDoc dflags alwaysQualify Opt_D_dump_rule_rewrites "" empty++ | dopt Opt_D_dump_rule_firings dflags+ = liftIO $ dumpSDoc dflags alwaysQualify Opt_D_dump_rule_firings "" empty++ | otherwise+ = return ()++ log_rule dflags flag hdr details+ = liftIO . dumpSDoc dflags alwaysQualify flag "" $+ sep [text hdr, nest 4 details]++trySeqRules :: SimplEnv+ -> OutExpr -> InExpr -- Scrutinee and RHS+ -> SimplCont+ -> SimplM (Maybe (SimplEnv, CoreExpr, SimplCont))+-- See Note [User-defined RULES for seq]+trySeqRules in_env scrut rhs cont+ = do { rule_base <- getSimplRules+ ; tryRules in_env (getRules rule_base seqId) seqId out_args rule_cont }+ where+ no_cast_scrut = drop_casts scrut+ scrut_ty = exprType no_cast_scrut+ seq_id_ty = idType seqId+ rhs_ty = substTy in_env (exprType rhs)+ out_args = [ TyArg { as_arg_ty = scrut_ty+ , as_hole_ty = seq_id_ty }+ , TyArg { as_arg_ty = rhs_ty+ , as_hole_ty = piResultTy seq_id_ty scrut_ty }+ , ValArg no_cast_scrut]+ rule_cont = ApplyToVal { sc_dup = NoDup, sc_arg = rhs+ , sc_env = in_env, sc_cont = cont }+ -- Lazily evaluated, so we don't do most of this++ drop_casts (Cast e _) = drop_casts e+ drop_casts e = e++{- Note [User-defined RULES for seq]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Given+ case (scrut |> co) of _ -> rhs+look for rules that match the expression+ seq @t1 @t2 scrut+where scrut :: t1+ rhs :: t2++If you find a match, rewrite it, and apply to 'rhs'.++Notice that we can simply drop casts on the fly here, which+makes it more likely that a rule will match.++See Note [User-defined RULES for seq] in MkId.++Note [Occurrence-analyse after rule firing]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+After firing a rule, we occurrence-analyse the instantiated RHS before+simplifying it. Usually this doesn't make much difference, but it can+be huge. Here's an example (simplCore/should_compile/T7785)++ map f (map f (map f xs)++= -- Use build/fold form of map, twice+ map f (build (\cn. foldr (mapFB c f) n+ (build (\cn. foldr (mapFB c f) n xs))))++= -- Apply fold/build rule+ map f (build (\cn. (\cn. foldr (mapFB c f) n xs) (mapFB c f) n))++= -- Beta-reduce+ -- Alas we have no occurrence-analysed, so we don't know+ -- that c is used exactly once+ map f (build (\cn. let c1 = mapFB c f in+ foldr (mapFB c1 f) n xs))++= -- Use mapFB rule: mapFB (mapFB c f) g = mapFB c (f.g)+ -- We can do this because (mapFB c n) is a PAP and hence expandable+ map f (build (\cn. let c1 = mapFB c n in+ foldr (mapFB c (f.f)) n x))++This is not too bad. But now do the same with the outer map, and+we get another use of mapFB, and t can interact with /both/ remaining+mapFB calls in the above expression. This is stupid because actually+that 'c1' binding is dead. The outer map introduces another c2. If+there is a deep stack of maps we get lots of dead bindings, and lots+of redundant work as we repeatedly simplify the result of firing rules.++The easy thing to do is simply to occurrence analyse the result of+the rule firing. Note that this occ-anals not only the RHS of the+rule, but also the function arguments, which by now are OutExprs.+E.g.+ RULE f (g x) = x+1++Call f (g BIG) --> (\x. x+1) BIG++The rule binders are lambda-bound and applied to the OutExpr arguments+(here BIG) which lack all internal occurrence info.++Is this inefficient? Not really: we are about to walk over the result+of the rule firing to simplify it, so occurrence analysis is at most+a constant factor.++Possible improvement: occ-anal the rules when putting them in the+database; and in the simplifier just occ-anal the OutExpr arguments.+But that's more complicated and the rule RHS is usually tiny; so I'm+just doing the simple thing.++Historical note: previously we did occ-anal the rules in Rule.hs,+but failed to occ-anal the OutExpr arguments, which led to the+nasty performance problem described above.+++Note [Optimising tagToEnum#]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we have an enumeration data type:++ data Foo = A | B | C++Then we want to transform++ case tagToEnum# x of ==> case x of+ A -> e1 DEFAULT -> e1+ B -> e2 1# -> e2+ C -> e3 2# -> e3++thereby getting rid of the tagToEnum# altogether. If there was a DEFAULT+alternative we retain it (remember it comes first). If not the case must+be exhaustive, and we reflect that in the transformed version by adding+a DEFAULT. Otherwise Lint complains that the new case is not exhaustive.+See #8317.++Note [Rules for recursive functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+You might think that we shouldn't apply rules for a loop breaker:+doing so might give rise to an infinite loop, because a RULE is+rather like an extra equation for the function:+ RULE: f (g x) y = x+y+ Eqn: f a y = a-y++But it's too drastic to disable rules for loop breakers.+Even the foldr/build rule would be disabled, because foldr+is recursive, and hence a loop breaker:+ foldr k z (build g) = g k z+So it's up to the programmer: rules can cause divergence+++************************************************************************+* *+ Rebuilding a case expression+* *+************************************************************************++Note [Case elimination]+~~~~~~~~~~~~~~~~~~~~~~~+The case-elimination transformation discards redundant case expressions.+Start with a simple situation:++ case x# of ===> let y# = x# in e+ y# -> e++(when x#, y# are of primitive type, of course). We can't (in general)+do this for algebraic cases, because we might turn bottom into+non-bottom!++The code in SimplUtils.prepareAlts has the effect of generalise this+idea to look for a case where we're scrutinising a variable, and we+know that only the default case can match. For example:++ case x of+ 0# -> ...+ DEFAULT -> ...(case x of+ 0# -> ...+ DEFAULT -> ...) ...++Here the inner case is first trimmed to have only one alternative, the+DEFAULT, after which it's an instance of the previous case. This+really only shows up in eliminating error-checking code.++Note that SimplUtils.mkCase combines identical RHSs. So++ case e of ===> case e of DEFAULT -> r+ True -> r+ False -> r++Now again the case may be elminated by the CaseElim transformation.+This includes things like (==# a# b#)::Bool so that we simplify+ case ==# a# b# of { True -> x; False -> x }+to just+ x+This particular example shows up in default methods for+comparison operations (e.g. in (>=) for Int.Int32)++Note [Case to let transformation]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If a case over a lifted type has a single alternative, and is being+used as a strict 'let' (all isDeadBinder bndrs), we may want to do+this transformation:++ case e of r ===> let r = e in ...r...+ _ -> ...r...++We treat the unlifted and lifted cases separately:++* Unlifted case: 'e' satisfies exprOkForSpeculation+ (ok-for-spec is needed to satisfy the let/app invariant).+ This turns case a +# b of r -> ...r...+ into let r = a +# b in ...r...+ and thence .....(a +# b)....++ However, if we have+ case indexArray# a i of r -> ...r...+ we might like to do the same, and inline the (indexArray# a i).+ But indexArray# is not okForSpeculation, so we don't build a let+ in rebuildCase (lest it get floated *out*), so the inlining doesn't+ happen either. Annoying.++* Lifted case: we need to be sure that the expression is already+ evaluated (exprIsHNF). If it's not already evaluated+ - we risk losing exceptions, divergence or+ user-specified thunk-forcing+ - even if 'e' is guaranteed to converge, we don't want to+ create a thunk (call by need) instead of evaluating it+ right away (call by value)++ However, we can turn the case into a /strict/ let if the 'r' is+ used strictly in the body. Then we won't lose divergence; and+ we won't build a thunk because the let is strict.+ See also Note [Eliminating redundant seqs]++ NB: absentError satisfies exprIsHNF: see Note [aBSENT_ERROR_ID] in MkCore.+ We want to turn+ case (absentError "foo") of r -> ...MkT r...+ into+ let r = absentError "foo" in ...MkT r...+++Note [Eliminating redundant seqs]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we have this:+ case x of r { _ -> ..r.. }+where 'r' is used strictly in (..r..), the case is effectively a 'seq'+on 'x', but since 'r' is used strictly anyway, we can safely transform to+ (...x...)++Note that this can change the error behaviour. For example, we might+transform+ case x of { _ -> error "bad" }+ --> error "bad"+which is might be puzzling if 'x' currently lambda-bound, but later gets+let-bound to (error "good").++Nevertheless, the paper "A semantics for imprecise exceptions" allows+this transformation. If you want to fix the evaluation order, use+'pseq'. See Trac #8900 for an example where the loss of this+transformation bit us in practice.++See also Note [Empty case alternatives] in CoreSyn.++Just for reference, the original code (added Jan 13) looked like this:+ || case_bndr_evald_next rhs++ case_bndr_evald_next :: CoreExpr -> Bool+ -- See Note [Case binder next]+ case_bndr_evald_next (Var v) = v == case_bndr+ case_bndr_evald_next (Cast e _) = case_bndr_evald_next e+ case_bndr_evald_next (App e _) = case_bndr_evald_next e+ case_bndr_evald_next (Case e _ _ _) = case_bndr_evald_next e+ case_bndr_evald_next _ = False++(This came up when fixing Trac #7542. See also Note [Eta reduction of+an eval'd function] in CoreUtils.)+++Further notes about case elimination+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider: test :: Integer -> IO ()+ test = print++Turns out that this compiles to:+ Print.test+ = \ eta :: Integer+ eta1 :: Void# ->+ case PrelNum.< eta PrelNum.zeroInteger of wild { __DEFAULT ->+ case hPutStr stdout+ (PrelNum.jtos eta ($w[] @ Char))+ eta1+ of wild1 { (# new_s, a4 #) -> PrelIO.lvl23 new_s }}++Notice the strange '<' which has no effect at all. This is a funny one.+It started like this:++f x y = if x < 0 then jtos x+ else if y==0 then "" else jtos x++At a particular call site we have (f v 1). So we inline to get++ if v < 0 then jtos x+ else if 1==0 then "" else jtos x++Now simplify the 1==0 conditional:++ if v<0 then jtos v else jtos v++Now common-up the two branches of the case:++ case (v<0) of DEFAULT -> jtos v++Why don't we drop the case? Because it's strict in v. It's technically+wrong to drop even unnecessary evaluations, and in practice they+may be a result of 'seq' so we *definitely* don't want to drop those.+I don't really know how to improve this situation.+-}++---------------------------------------------------------+-- Eliminate the case if possible++rebuildCase, reallyRebuildCase+ :: SimplEnv+ -> OutExpr -- Scrutinee+ -> InId -- Case binder+ -> [InAlt] -- Alternatives (inceasing order)+ -> SimplCont+ -> SimplM (SimplFloats, OutExpr)++--------------------------------------------------+-- 1. Eliminate the case if there's a known constructor+--------------------------------------------------++rebuildCase env scrut case_bndr alts cont+ | Lit lit <- scrut -- No need for same treatment as constructors+ -- because literals are inlined more vigorously+ , not (litIsLifted lit)+ = do { tick (KnownBranch case_bndr)+ ; case findAlt (LitAlt lit) alts of+ Nothing -> missingAlt env case_bndr alts cont+ Just (_, bs, rhs) -> simple_rhs bs rhs }++ | Just (con, ty_args, other_args) <- exprIsConApp_maybe (getUnfoldingInRuleMatch env) scrut+ -- Works when the scrutinee is a variable with a known unfolding+ -- as well as when it's an explicit constructor application+ = do { tick (KnownBranch case_bndr)+ ; case findAlt (DataAlt con) alts of+ Nothing -> missingAlt env case_bndr alts cont+ Just (DEFAULT, bs, rhs) -> simple_rhs bs rhs+ Just (_, bs, rhs) -> knownCon env scrut con ty_args other_args+ case_bndr bs rhs cont+ }+ where+ simple_rhs bs rhs = ASSERT( null bs )+ do { (floats1, env') <- simplNonRecX env case_bndr scrut+ -- scrut is a constructor application,+ -- hence satisfies let/app invariant+ ; (floats2, expr') <- simplExprF env' rhs cont+ ; return (floats1 `addFloats` floats2, expr') }+++--------------------------------------------------+-- 2. Eliminate the case if scrutinee is evaluated+--------------------------------------------------++rebuildCase env scrut case_bndr alts@[(_, bndrs, rhs)] cont+ -- See if we can get rid of the case altogether+ -- See Note [Case elimination]+ -- mkCase made sure that if all the alternatives are equal,+ -- then there is now only one (DEFAULT) rhs++ -- 2a. Dropping the case altogether, if+ -- a) it binds nothing (so it's really just a 'seq')+ -- b) evaluating the scrutinee has no side effects+ | is_plain_seq+ , exprOkForSideEffects scrut+ -- The entire case is dead, so we can drop it+ -- if the scrutinee converges without having imperative+ -- side effects or raising a Haskell exception+ -- See Note [PrimOp can_fail and has_side_effects] in PrimOp+ = simplExprF env rhs cont++ -- 2b. Turn the case into a let, if+ -- a) it binds only the case-binder+ -- b) unlifted case: the scrutinee is ok-for-speculation+ -- lifted case: the scrutinee is in HNF (or will later be demanded)+ -- See Note [Case to let transformation]+ | all_dead_bndrs+ , if isUnliftedType (idType case_bndr)+ then exprOkForSpeculation scrut+ else exprIsHNF scrut || scrut_is_demanded_var scrut+ = do { tick (CaseElim case_bndr)+ ; (floats1, env') <- simplNonRecX env case_bndr scrut+ ; (floats2, expr') <- simplExprF env' rhs cont+ ; return (floats1 `addFloats` floats2, expr') }++ -- 2c. Try the seq rules if+ -- a) it binds only the case binder+ -- b) a rule for seq applies+ -- See Note [User-defined RULES for seq] in MkId+ | is_plain_seq+ = do { mb_rule <- trySeqRules env scrut rhs cont+ ; case mb_rule of+ Just (env', rule_rhs, cont') -> simplExprF env' rule_rhs cont'+ Nothing -> reallyRebuildCase env scrut case_bndr alts cont }+ where+ all_dead_bndrs = all isDeadBinder bndrs -- bndrs are [InId]+ is_plain_seq = all_dead_bndrs && isDeadBinder case_bndr -- Evaluation *only* for effect++ scrut_is_demanded_var :: CoreExpr -> Bool+ -- See Note [Eliminating redundant seqs]+ scrut_is_demanded_var (Cast s _) = scrut_is_demanded_var s+ scrut_is_demanded_var (Var _) = isStrictDmd (idDemandInfo case_bndr)+ scrut_is_demanded_var _ = False+++rebuildCase env scrut case_bndr alts cont+ = reallyRebuildCase env scrut case_bndr alts cont++--------------------------------------------------+-- 3. Catch-all case+--------------------------------------------------++reallyRebuildCase env scrut case_bndr alts cont+ | not (sm_case_case (getMode env))+ = do { case_expr <- simplAlts env scrut case_bndr alts+ (mkBoringStop (contHoleType cont))+ ; rebuild env case_expr cont }++ | otherwise+ = do { (floats, cont') <- mkDupableCaseCont env alts cont+ ; case_expr <- simplAlts (env `setInScopeFromF` floats)+ scrut case_bndr alts cont'+ ; return (floats, case_expr) }++{-+simplCaseBinder checks whether the scrutinee is a variable, v. If so,+try to eliminate uses of v in the RHSs in favour of case_bndr; that+way, there's a chance that v will now only be used once, and hence+inlined.++Historical note: we use to do the "case binder swap" in the Simplifier+so there were additional complications if the scrutinee was a variable.+Now the binder-swap stuff is done in the occurrence analyser; see+OccurAnal Note [Binder swap].++Note [knownCon occ info]+~~~~~~~~~~~~~~~~~~~~~~~~+If the case binder is not dead, then neither are the pattern bound+variables:+ case <any> of x { (a,b) ->+ case x of { (p,q) -> p } }+Here (a,b) both look dead, but come alive after the inner case is eliminated.+The point is that we bring into the envt a binding+ let x = (a,b)+after the outer case, and that makes (a,b) alive. At least we do unless+the case binder is guaranteed dead.++Note [Case alternative occ info]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we are simply reconstructing a case (the common case), we always+zap the occurrence info on the binders in the alternatives. Even+if the case binder is dead, the scrutinee is usually a variable, and *that*+can bring the case-alternative binders back to life.+See Note [Add unfolding for scrutinee]++Note [Improving seq]+~~~~~~~~~~~~~~~~~~~+Consider+ type family F :: * -> *+ type instance F Int = Int++We'd like to transform+ case e of (x :: F Int) { DEFAULT -> rhs }+===>+ case e `cast` co of (x'::Int)+ I# x# -> let x = x' `cast` sym co+ in rhs++so that 'rhs' can take advantage of the form of x'. Notice that Note+[Case of cast] (in OccurAnal) may then apply to the result.++We'd also like to eliminate empty types (Trac #13468). So if++ data Void+ type instance F Bool = Void++then we'd like to transform+ case (x :: F Bool) of { _ -> error "urk" }+===>+ case (x |> co) of (x' :: Void) of {}++Nota Bene: we used to have a built-in rule for 'seq' that dropped+casts, so that+ case (x |> co) of { _ -> blah }+dropped the cast; in order to improve the chances of trySeqRules+firing. But that works in the /opposite/ direction to Note [Improving+seq] so there's a danger of flip/flopping. Better to make trySeqRules+insensitive to the cast, which is now is.++The need for [Improving seq] showed up in Roman's experiments. Example:+ foo :: F Int -> Int -> Int+ foo t n = t `seq` bar n+ where+ bar 0 = 0+ bar n = bar (n - case t of TI i -> i)+Here we'd like to avoid repeated evaluating t inside the loop, by+taking advantage of the `seq`.++At one point I did transformation in LiberateCase, but it's more+robust here. (Otherwise, there's a danger that we'll simply drop the+'seq' altogether, before LiberateCase gets to see it.)+-}++simplAlts :: SimplEnv+ -> OutExpr -- Scrutinee+ -> InId -- Case binder+ -> [InAlt] -- Non-empty+ -> SimplCont+ -> SimplM OutExpr -- Returns the complete simplified case expression++simplAlts env0 scrut case_bndr alts cont'+ = do { traceSmpl "simplAlts" (vcat [ ppr case_bndr+ , text "cont':" <+> ppr cont'+ , text "in_scope" <+> ppr (seInScope env0) ])+ ; (env1, case_bndr1) <- simplBinder env0 case_bndr+ ; let case_bndr2 = case_bndr1 `setIdUnfolding` evaldUnfolding+ env2 = modifyInScope env1 case_bndr2+ -- See Note [Case binder evaluated-ness]++ ; fam_envs <- getFamEnvs+ ; (alt_env', scrut', case_bndr') <- improveSeq fam_envs env2 scrut+ case_bndr case_bndr2 alts++ ; (imposs_deflt_cons, in_alts) <- prepareAlts scrut' case_bndr' alts+ -- NB: it's possible that the returned in_alts is empty: this is handled+ -- by the caller (rebuildCase) in the missingAlt function++ ; alts' <- mapM (simplAlt alt_env' (Just scrut') imposs_deflt_cons case_bndr' cont') in_alts+ ; -- pprTrace "simplAlts" (ppr case_bndr $$ ppr alts_ty $$ ppr alts_ty' $$ ppr alts $$ ppr cont') $++ ; let alts_ty' = contResultType cont'+ -- See Note [Avoiding space leaks in OutType]+ ; seqType alts_ty' `seq`+ mkCase (seDynFlags env0) scrut' case_bndr' alts_ty' alts' }+++------------------------------------+improveSeq :: (FamInstEnv, FamInstEnv) -> SimplEnv+ -> OutExpr -> InId -> OutId -> [InAlt]+ -> SimplM (SimplEnv, OutExpr, OutId)+-- Note [Improving seq]+improveSeq fam_envs env scrut case_bndr case_bndr1 [(DEFAULT,_,_)]+ | Just (co, ty2) <- topNormaliseType_maybe fam_envs (idType case_bndr1)+ = do { case_bndr2 <- newId (fsLit "nt") ty2+ ; let rhs = DoneEx (Var case_bndr2 `Cast` mkSymCo co) Nothing+ env2 = extendIdSubst env case_bndr rhs+ ; return (env2, scrut `Cast` co, case_bndr2) }++improveSeq _ env scrut _ case_bndr1 _+ = return (env, scrut, case_bndr1)+++------------------------------------+simplAlt :: SimplEnv+ -> Maybe OutExpr -- The scrutinee+ -> [AltCon] -- These constructors can't be present when+ -- matching the DEFAULT alternative+ -> OutId -- The case binder+ -> SimplCont+ -> InAlt+ -> SimplM OutAlt++simplAlt env _ imposs_deflt_cons case_bndr' cont' (DEFAULT, bndrs, rhs)+ = ASSERT( null bndrs )+ do { let env' = addBinderUnfolding env case_bndr'+ (mkOtherCon imposs_deflt_cons)+ -- Record the constructors that the case-binder *can't* be.+ ; rhs' <- simplExprC env' rhs cont'+ ; return (DEFAULT, [], rhs') }++simplAlt env scrut' _ case_bndr' cont' (LitAlt lit, bndrs, rhs)+ = ASSERT( null bndrs )+ do { env' <- addAltUnfoldings env scrut' case_bndr' (Lit lit)+ ; rhs' <- simplExprC env' rhs cont'+ ; return (LitAlt lit, [], rhs') }++simplAlt env scrut' _ case_bndr' cont' (DataAlt con, vs, rhs)+ = do { -- Deal with the pattern-bound variables+ -- Mark the ones that are in ! positions in the+ -- data constructor as certainly-evaluated.+ -- NB: simplLamBinders preserves this eval info+ ; let vs_with_evals = add_evals (dataConRepStrictness con)+ ; (env', vs') <- simplLamBndrs env vs_with_evals++ -- Bind the case-binder to (con args)+ ; let inst_tys' = tyConAppArgs (idType case_bndr')+ con_app :: OutExpr+ con_app = mkConApp2 con inst_tys' vs'++ ; env'' <- addAltUnfoldings env' scrut' case_bndr' con_app+ ; rhs' <- simplExprC env'' rhs cont'+ ; return (DataAlt con, vs', rhs') }+ where+ -- add_evals records the evaluated-ness of the bound variables of+ -- a case pattern. This is *important*. Consider+ -- data T = T !Int !Int+ --+ -- case x of { T a b -> T (a+1) b }+ --+ -- We really must record that b is already evaluated so that we don't+ -- go and re-evaluate it when constructing the result.+ -- See Note [Data-con worker strictness] in MkId.hs+ add_evals the_strs+ = go vs the_strs+ where+ go [] [] = []+ go (v:vs') strs | isTyVar v = v : go vs' strs+ go (v:vs') (str:strs) = zap str v : go vs' strs+ go _ _ = pprPanic "cat_evals"+ (ppr con $$+ ppr vs $$+ ppr_with_length the_strs $$+ ppr_with_length (dataConRepArgTys con) $$+ ppr_with_length (dataConRepStrictness con))+ where+ ppr_with_length list+ = ppr list <+> parens (text "length =" <+> ppr (length list))+ -- NB: If this panic triggers, note that+ -- NoStrictnessMark doesn't print!++ zap str v = setCaseBndrEvald str $ -- Add eval'dness info+ zapIdOccInfo v -- And kill occ info;+ -- see Note [Case alternative occ info]++addAltUnfoldings :: SimplEnv -> Maybe OutExpr -> OutId -> OutExpr -> SimplM SimplEnv+addAltUnfoldings env scrut case_bndr con_app+ = do { let con_app_unf = mk_simple_unf con_app+ env1 = addBinderUnfolding env case_bndr con_app_unf++ -- See Note [Add unfolding for scrutinee]+ env2 = case scrut of+ Just (Var v) -> addBinderUnfolding env1 v con_app_unf+ Just (Cast (Var v) co) -> addBinderUnfolding env1 v $+ mk_simple_unf (Cast con_app (mkSymCo co))+ _ -> env1++ ; traceSmpl "addAltUnf" (vcat [ppr case_bndr <+> ppr scrut, ppr con_app])+ ; return env2 }+ where+ mk_simple_unf = mkSimpleUnfolding (seDynFlags env)++addBinderUnfolding :: SimplEnv -> Id -> Unfolding -> SimplEnv+addBinderUnfolding env bndr unf+ | debugIsOn, Just tmpl <- maybeUnfoldingTemplate unf+ = WARN( not (eqType (idType bndr) (exprType tmpl)),+ ppr bndr $$ ppr (idType bndr) $$ ppr tmpl $$ ppr (exprType tmpl) )+ modifyInScope env (bndr `setIdUnfolding` unf)++ | otherwise+ = modifyInScope env (bndr `setIdUnfolding` unf)++zapBndrOccInfo :: Bool -> Id -> Id+-- Consider case e of b { (a,b) -> ... }+-- Then if we bind b to (a,b) in "...", and b is not dead,+-- then we must zap the deadness info on a,b+zapBndrOccInfo keep_occ_info pat_id+ | keep_occ_info = pat_id+ | otherwise = zapIdOccInfo pat_id++{- Note [Case binder evaluated-ness]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We pin on a (OtherCon []) unfolding to the case-binder of a Case,+even though it'll be over-ridden in every case alternative with a more+informative unfolding. Why? Because suppose a later, less clever, pass+simply replaces all occurrences of the case binder with the binder itself;+then Lint may complain about the let/app invariant. Example+ case e of b { DEFAULT -> let v = reallyUnsafePtrEq# b y in ....+ ; K -> blah }++The let/app invariant requires that y is evaluated in the call to+reallyUnsafePtrEq#, which it is. But we still want that to be true if we+propagate binders to occurrences.++This showed up in Trac #13027.++Note [Add unfolding for scrutinee]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In general it's unlikely that a variable scrutinee will appear+in the case alternatives case x of { ...x unlikely to appear... }+because the binder-swap in OccAnal has got rid of all such occurrences+See Note [Binder swap] in OccAnal.++BUT it is still VERY IMPORTANT to add a suitable unfolding for a+variable scrutinee, in simplAlt. Here's why+ case x of y+ (a,b) -> case b of c+ I# v -> ...(f y)...+There is no occurrence of 'b' in the (...(f y)...). But y gets+the unfolding (a,b), and *that* mentions b. If f has a RULE+ RULE f (p, I# q) = ...+we want that rule to match, so we must extend the in-scope env with a+suitable unfolding for 'y'. It's *essential* for rule matching; but+it's also good for case-elimintation -- suppose that 'f' was inlined+and did multi-level case analysis, then we'd solve it in one+simplifier sweep instead of two.++Exactly the same issue arises in SpecConstr;+see Note [Add scrutinee to ValueEnv too] in SpecConstr++HOWEVER, given+ case x of y { Just a -> r1; Nothing -> r2 }+we do not want to add the unfolding x -> y to 'x', which might seem cool,+since 'y' itself has different unfoldings in r1 and r2. Reason: if we+did that, we'd have to zap y's deadness info and that is a very useful+piece of information.++So instead we add the unfolding x -> Just a, and x -> Nothing in the+respective RHSs.+++************************************************************************+* *+\subsection{Known constructor}+* *+************************************************************************++We are a bit careful with occurrence info. Here's an example++ (\x* -> case x of (a*, b) -> f a) (h v, e)++where the * means "occurs once". This effectively becomes+ case (h v, e) of (a*, b) -> f a)+and then+ let a* = h v; b = e in f a+and then+ f (h v)++All this should happen in one sweep.+-}++knownCon :: SimplEnv+ -> OutExpr -- The scrutinee+ -> DataCon -> [OutType] -> [OutExpr] -- The scrutinee (in pieces)+ -> InId -> [InBndr] -> InExpr -- The alternative+ -> SimplCont+ -> SimplM (SimplFloats, OutExpr)++knownCon env scrut dc dc_ty_args dc_args bndr bs rhs cont+ = do { (floats1, env1) <- bind_args env bs dc_args+ ; (floats2, env2) <- bind_case_bndr env1+ ; (floats3, expr') <- simplExprF env2 rhs cont+ ; return (floats1 `addFloats` floats2 `addFloats` floats3, expr') }+ where+ zap_occ = zapBndrOccInfo (isDeadBinder bndr) -- bndr is an InId++ -- Ugh!+ bind_args env' [] _ = return (emptyFloats env', env')++ bind_args env' (b:bs') (Type ty : args)+ = ASSERT( isTyVar b )+ bind_args (extendTvSubst env' b ty) bs' args++ bind_args env' (b:bs') (Coercion co : args)+ = ASSERT( isCoVar b )+ bind_args (extendCvSubst env' b co) bs' args++ bind_args env' (b:bs') (arg : args)+ = ASSERT( isId b )+ do { let b' = zap_occ b+ -- Note that the binder might be "dead", because it doesn't+ -- occur in the RHS; and simplNonRecX may therefore discard+ -- it via postInlineUnconditionally.+ -- Nevertheless we must keep it if the case-binder is alive,+ -- because it may be used in the con_app. See Note [knownCon occ info]+ ; (floats1, env2) <- simplNonRecX env' b' arg -- arg satisfies let/app invariant+ ; (floats2, env3) <- bind_args env2 bs' args+ ; return (floats1 `addFloats` floats2, env3) }++ bind_args _ _ _ =+ pprPanic "bind_args" $ ppr dc $$ ppr bs $$ ppr dc_args $$+ text "scrut:" <+> ppr scrut++ -- It's useful to bind bndr to scrut, rather than to a fresh+ -- binding x = Con arg1 .. argn+ -- because very often the scrut is a variable, so we avoid+ -- creating, and then subsequently eliminating, a let-binding+ -- BUT, if scrut is a not a variable, we must be careful+ -- about duplicating the arg redexes; in that case, make+ -- a new con-app from the args+ bind_case_bndr env+ | isDeadBinder bndr = return (emptyFloats env, env)+ | exprIsTrivial scrut = return (emptyFloats env+ , extendIdSubst env bndr (DoneEx scrut Nothing))+ | otherwise = do { dc_args <- mapM (simplVar env) bs+ -- dc_ty_args are aready OutTypes,+ -- but bs are InBndrs+ ; let con_app = Var (dataConWorkId dc)+ `mkTyApps` dc_ty_args+ `mkApps` dc_args+ ; simplNonRecX env bndr con_app }++-------------------+missingAlt :: SimplEnv -> Id -> [InAlt] -> SimplCont+ -> SimplM (SimplFloats, OutExpr)+ -- This isn't strictly an error, although it is unusual.+ -- It's possible that the simplifier might "see" that+ -- an inner case has no accessible alternatives before+ -- it "sees" that the entire branch of an outer case is+ -- inaccessible. So we simply put an error case here instead.+missingAlt env case_bndr _ cont+ = WARN( True, text "missingAlt" <+> ppr case_bndr )+ -- See Note [Avoiding space leaks in OutType]+ let cont_ty = contResultType cont+ in seqType cont_ty `seq`+ return (emptyFloats env, mkImpossibleExpr cont_ty)++{-+************************************************************************+* *+\subsection{Duplicating continuations}+* *+************************************************************************++Consider+ let x* = case e of { True -> e1; False -> e2 }+ in b+where x* is a strict binding. Then mkDupableCont will be given+the continuation+ case [] of { True -> e1; False -> e2 } ; let x* = [] in b ; stop+and will split it into+ dupable: case [] of { True -> $j1; False -> $j2 } ; stop+ join floats: $j1 = e1, $j2 = e2+ non_dupable: let x* = [] in b; stop++Putting this back together would give+ let x* = let { $j1 = e1; $j2 = e2 } in+ case e of { True -> $j1; False -> $j2 }+ in b+(Of course we only do this if 'e' wants to duplicate that continuation.)+Note how important it is that the new join points wrap around the+inner expression, and not around the whole thing.++In contrast, any let-bindings introduced by mkDupableCont can wrap+around the entire thing.++Note [Bottom alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~+When we have+ case (case x of { A -> error .. ; B -> e; C -> error ..)+ of alts+then we can just duplicate those alts because the A and C cases+will disappear immediately. This is more direct than creating+join points and inlining them away. See Trac #4930.+-}++--------------------+mkDupableCaseCont :: SimplEnv -> [InAlt] -> SimplCont+ -> SimplM (SimplFloats, SimplCont)+mkDupableCaseCont env alts cont+ | altsWouldDup alts = mkDupableCont env cont+ | otherwise = return (emptyFloats env, cont)++altsWouldDup :: [InAlt] -> Bool -- True iff strictly > 1 non-bottom alternative+altsWouldDup [] = False -- See Note [Bottom alternatives]+altsWouldDup [_] = False+altsWouldDup (alt:alts)+ | is_bot_alt alt = altsWouldDup alts+ | otherwise = not (all is_bot_alt alts)+ where+ is_bot_alt (_,_,rhs) = exprIsBottom rhs++-------------------------+mkDupableCont :: SimplEnv -> SimplCont+ -> SimplM ( SimplFloats -- Incoming SimplEnv augmented with+ -- extra let/join-floats and in-scope variables+ , SimplCont) -- dup_cont: duplicable continuation++mkDupableCont env cont+ | contIsDupable cont+ = return (emptyFloats env, cont)++mkDupableCont _ (Stop {}) = panic "mkDupableCont" -- Handled by previous eqn++mkDupableCont env (CastIt ty cont)+ = do { (floats, cont') <- mkDupableCont env cont+ ; return (floats, CastIt ty cont') }++-- Duplicating ticks for now, not sure if this is good or not+mkDupableCont env (TickIt t cont)+ = do { (floats, cont') <- mkDupableCont env cont+ ; return (floats, TickIt t cont') }++mkDupableCont env (StrictBind { sc_bndr = bndr, sc_bndrs = bndrs+ , sc_body = body, sc_env = se, sc_cont = cont})+ -- See Note [Duplicating StrictBind]+ = do { let sb_env = se `setInScopeFromE` env+ ; (sb_env1, bndr') <- simplBinder sb_env bndr+ ; (floats1, join_inner) <- simplLam sb_env1 bndrs body cont+ -- No need to use mkDupableCont before simplLam; we+ -- use cont once here, and then share the result if necessary++ ; let join_body = wrapFloats floats1 join_inner+ res_ty = contResultType cont++ ; (floats2, body2)+ <- if exprIsDupable (seDynFlags env) join_body+ then return (emptyFloats env, join_body)+ else do { join_bndr <- newJoinId [bndr'] res_ty+ ; let join_call = App (Var join_bndr) (Var bndr')+ join_rhs = Lam (setOneShotLambda bndr') join_body+ join_bind = NonRec join_bndr join_rhs+ floats = emptyFloats env `extendFloats` join_bind+ ; return (floats, join_call) }+ ; return ( floats2+ , StrictBind { sc_bndr = bndr', sc_bndrs = []+ , sc_body = body2+ , sc_env = zapSubstEnv se `setInScopeFromF` floats2+ -- See Note [StaticEnv invariant] in SimplUtils+ , sc_dup = OkToDup+ , sc_cont = mkBoringStop res_ty } ) }++mkDupableCont env (StrictArg { sc_fun = info, sc_cci = cci, sc_cont = cont })+ -- See Note [Duplicating StrictArg]+ -- NB: sc_dup /= OkToDup; that is caught earlier by contIsDupable+ = do { (floats1, cont') <- mkDupableCont env cont+ ; (floats_s, args') <- mapAndUnzipM (makeTrivialArg (getMode env))+ (ai_args info)+ ; return ( foldl addLetFloats floats1 floats_s+ , StrictArg { sc_fun = info { ai_args = args' }+ , sc_cci = cci+ , sc_cont = cont'+ , sc_dup = OkToDup} ) }++mkDupableCont env (ApplyToTy { sc_cont = cont+ , sc_arg_ty = arg_ty, sc_hole_ty = hole_ty })+ = do { (floats, cont') <- mkDupableCont env cont+ ; return (floats, ApplyToTy { sc_cont = cont'+ , sc_arg_ty = arg_ty, sc_hole_ty = hole_ty }) }++mkDupableCont env (ApplyToVal { sc_arg = arg, sc_dup = dup+ , sc_env = se, sc_cont = cont })+ = -- e.g. [...hole...] (...arg...)+ -- ==>+ -- let a = ...arg...+ -- in [...hole...] a+ -- NB: sc_dup /= OkToDup; that is caught earlier by contIsDupable+ do { (floats1, cont') <- mkDupableCont env cont+ ; let env' = env `setInScopeFromF` floats1+ ; (_, se', arg') <- simplArg env' dup se arg+ ; (let_floats2, arg'') <- makeTrivial (getMode env) NotTopLevel (fsLit "karg") arg'+ ; let all_floats = floats1 `addLetFloats` let_floats2+ ; return ( all_floats+ , ApplyToVal { sc_arg = arg''+ , sc_env = se' `setInScopeFromF` all_floats+ -- Ensure that sc_env includes the free vars of+ -- arg'' in its in-scope set, even if makeTrivial+ -- has turned arg'' into a fresh variable+ -- See Note [StaticEnv invariant] in SimplUtils+ , sc_dup = OkToDup, sc_cont = cont' }) }++mkDupableCont env (Select { sc_bndr = case_bndr, sc_alts = alts+ , sc_env = se, sc_cont = cont })+ = -- e.g. (case [...hole...] of { pi -> ei })+ -- ===>+ -- let ji = \xij -> ei+ -- in case [...hole...] of { pi -> ji xij }+ -- NB: sc_dup /= OkToDup; that is caught earlier by contIsDupable+ do { tick (CaseOfCase case_bndr)+ ; (floats, alt_cont) <- mkDupableCaseCont env alts cont+ -- NB: We call mkDupableCaseCont here to make cont duplicable+ -- (if necessary, depending on the number of alts)+ -- And this is important: see Note [Fusing case continuations]++ ; let alt_env = se `setInScopeFromF` floats+ ; (alt_env', case_bndr') <- simplBinder alt_env case_bndr+ ; alts' <- mapM (simplAlt alt_env' Nothing [] case_bndr' alt_cont) alts+ -- Safe to say that there are no handled-cons for the DEFAULT case+ -- NB: simplBinder does not zap deadness occ-info, so+ -- a dead case_bndr' will still advertise its deadness+ -- This is really important because in+ -- case e of b { (# p,q #) -> ... }+ -- b is always dead, and indeed we are not allowed to bind b to (# p,q #),+ -- which might happen if e was an explicit unboxed pair and b wasn't marked dead.+ -- In the new alts we build, we have the new case binder, so it must retain+ -- its deadness.+ -- NB: we don't use alt_env further; it has the substEnv for+ -- the alternatives, and we don't want that++ ; (join_floats, alts'') <- mapAccumLM (mkDupableAlt (seDynFlags env) case_bndr')+ emptyJoinFloats alts'++ ; let all_floats = floats `addJoinFloats` join_floats+ -- Note [Duplicated env]+ ; return (all_floats+ , Select { sc_dup = OkToDup+ , sc_bndr = case_bndr'+ , sc_alts = alts''+ , sc_env = zapSubstEnv se `setInScopeFromF` all_floats+ -- See Note [StaticEnv invariant] in SimplUtils+ , sc_cont = mkBoringStop (contResultType cont) } ) }++mkDupableAlt :: DynFlags -> OutId+ -> JoinFloats -> OutAlt+ -> SimplM (JoinFloats, OutAlt)+mkDupableAlt dflags case_bndr jfloats (con, bndrs', rhs')+ | exprIsDupable dflags rhs' -- Note [Small alternative rhs]+ = return (jfloats, (con, bndrs', rhs'))++ | otherwise+ = do { let rhs_ty' = exprType rhs'+ scrut_ty = idType case_bndr+ case_bndr_w_unf+ = case con of+ DEFAULT -> case_bndr+ DataAlt dc -> setIdUnfolding case_bndr unf+ where+ -- See Note [Case binders and join points]+ unf = mkInlineUnfolding rhs+ rhs = mkConApp2 dc (tyConAppArgs scrut_ty) bndrs'++ LitAlt {} -> WARN( True, text "mkDupableAlt"+ <+> ppr case_bndr <+> ppr con )+ case_bndr+ -- The case binder is alive but trivial, so why has+ -- it not been substituted away?++ final_bndrs'+ | isDeadBinder case_bndr = filter abstract_over bndrs'+ | otherwise = bndrs' ++ [case_bndr_w_unf]++ abstract_over bndr+ | isTyVar bndr = True -- Abstract over all type variables just in case+ | otherwise = not (isDeadBinder bndr)+ -- The deadness info on the new Ids is preserved by simplBinders+ final_args = varsToCoreExprs final_bndrs'+ -- Note [Join point abstraction]++ -- We make the lambdas into one-shot-lambdas. The+ -- join point is sure to be applied at most once, and doing so+ -- prevents the body of the join point being floated out by+ -- the full laziness pass+ really_final_bndrs = map one_shot final_bndrs'+ one_shot v | isId v = setOneShotLambda v+ | otherwise = v+ join_rhs = mkLams really_final_bndrs rhs'++ ; join_bndr <- newJoinId final_bndrs' rhs_ty'++ ; let join_call = mkApps (Var join_bndr) final_args+ alt' = (con, bndrs', join_call)++ ; return ( jfloats `addJoinFlts` unitJoinFloat (NonRec join_bndr join_rhs)+ , alt') }+ -- See Note [Duplicated env]++{-+Note [Fusing case continuations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's important to fuse two successive case continuations when the+first has one alternative. That's why we call prepareCaseCont here.+Consider this, which arises from thunk splitting (see Note [Thunk+splitting] in WorkWrap):++ let+ x* = case (case v of {pn -> rn}) of+ I# a -> I# a+ in body++The simplifier will find+ (Var v) with continuation+ Select (pn -> rn) (+ Select [I# a -> I# a] (+ StrictBind body Stop++So we'll call mkDupableCont on+ Select [I# a -> I# a] (StrictBind body Stop)+There is just one alternative in the first Select, so we want to+simplify the rhs (I# a) with continuation (StrictBind body Stop)+Supposing that body is big, we end up with+ let $j a = <let x = I# a in body>+ in case v of { pn -> case rn of+ I# a -> $j a }+This is just what we want because the rn produces a box that+the case rn cancels with.++See Trac #4957 a fuller example.++Note [Case binders and join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this+ case (case .. ) of c {+ I# c# -> ....c....++If we make a join point with c but not c# we get+ $j = \c -> ....c....++But if later inlining scrutinises the c, thus++ $j = \c -> ... case c of { I# y -> ... } ...++we won't see that 'c' has already been scrutinised. This actually+happens in the 'tabulate' function in wave4main, and makes a significant+difference to allocation.++An alternative plan is this:++ $j = \c# -> let c = I# c# in ...c....++but that is bad if 'c' is *not* later scrutinised.++So instead we do both: we pass 'c' and 'c#' , and record in c's inlining+(a stable unfolding) that it's really I# c#, thus++ $j = \c# -> \c[=I# c#] -> ...c....++Absence analysis may later discard 'c'.++NB: take great care when doing strictness analysis;+ see Note [Lambda-bound unfoldings] in DmdAnal.++Also note that we can still end up passing stuff that isn't used. Before+strictness analysis we have+ let $j x y c{=(x,y)} = (h c, ...)+ in ...+After strictness analysis we see that h is strict, we end up with+ let $j x y c{=(x,y)} = ($wh x y, ...)+and c is unused.++Note [Duplicated env]+~~~~~~~~~~~~~~~~~~~~~+Some of the alternatives are simplified, but have not been turned into a join point+So they *must* have a zapped subst-env. So we can't use completeNonRecX to+bind the join point, because it might to do PostInlineUnconditionally, and+we'd lose that when zapping the subst-env. We could have a per-alt subst-env,+but zapping it (as we do in mkDupableCont, the Select case) is safe, and+at worst delays the join-point inlining.++Note [Small alternative rhs]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It is worth checking for a small RHS because otherwise we+get extra let bindings that may cause an extra iteration of the simplifier to+inline back in place. Quite often the rhs is just a variable or constructor.+The Ord instance of Maybe in PrelMaybe.hs, for example, took several extra+iterations because the version with the let bindings looked big, and so wasn't+inlined, but after the join points had been inlined it looked smaller, and so+was inlined.++NB: we have to check the size of rhs', not rhs.+Duplicating a small InAlt might invalidate occurrence information+However, if it *is* dupable, we return the *un* simplified alternative,+because otherwise we'd need to pair it up with an empty subst-env....+but we only have one env shared between all the alts.+(Remember we must zap the subst-env before re-simplifying something).+Rather than do this we simply agree to re-simplify the original (small) thing later.++Note [Funky mkLamTypes]+~~~~~~~~~~~~~~~~~~~~~~+Notice the funky mkLamTypes. If the constructor has existentials+it's possible that the join point will be abstracted over+type variables as well as term variables.+ Example: Suppose we have+ data T = forall t. C [t]+ Then faced with+ case (case e of ...) of+ C t xs::[t] -> rhs+ We get the join point+ let j :: forall t. [t] -> ...+ j = /\t \xs::[t] -> rhs+ in+ case (case e of ...) of+ C t xs::[t] -> j t xs++Note [Duplicating StrictArg]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We make a StrictArg duplicable simply by making all its+stored-up arguments (in sc_fun) trivial, by let-binding+them. Thus:+ f E [..hole..]+ ==> let a = E+ in f a [..hole..]+Now if the thing in the hole is a case expression (which is when+we'll call mkDupableCont), we'll push the function call into the+branches, which is what we want. Now RULES for f may fire, and+call-pattern specialisation. Here's an example from Trac #3116+ go (n+1) (case l of+ 1 -> bs'+ _ -> Chunk p fpc (o+1) (l-1) bs')+If we can push the call for 'go' inside the case, we get+call-pattern specialisation for 'go', which is *crucial* for+this program.++Here is the (&&) example:+ && E (case x of { T -> F; F -> T })+ ==> let a = E in+ case x of { T -> && a F; F -> && a T }+Much better!++Notice that+ * Arguments to f *after* the strict one are handled by+ the ApplyToVal case of mkDupableCont. Eg+ f [..hole..] E++ * We can only do the let-binding of E because the function+ part of a StrictArg continuation is an explicit syntax+ tree. In earlier versions we represented it as a function+ (CoreExpr -> CoreEpxr) which we couldn't take apart.++Historical aide: previously we did this (where E is a+big argument:+ f E [..hole..]+ ==> let $j = \a -> f E a+ in $j [..hole..]++But this is terrible! Here's an example:+ && E (case x of { T -> F; F -> T })+Now, && is strict so we end up simplifying the case with+an ArgOf continuation. If we let-bind it, we get+ let $j = \v -> && E v+ in simplExpr (case x of { T -> F; F -> T })+ (ArgOf (\r -> $j r)+And after simplifying more we get+ let $j = \v -> && E v+ in case x of { T -> $j F; F -> $j T }+Which is a Very Bad Thing+++Note [Duplicating StrictBind]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We make a StrictBind duplicable in a very similar way to+that for case expressions. After all,+ let x* = e in b is similar to case e of x -> b++So we potentially make a join-point for the body, thus:+ let x = [] in b ==> join j x = b+ in let x = [] in j x+++Note [Join point abstraction] Historical note+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+NB: This note is now historical, describing how (in the past) we used+to add a void argument to nullary join points. But now that "join+point" is not a fuzzy concept but a formal syntactic construct (as+distinguished by the JoinId constructor of IdDetails), each of these+concerns is handled separately, with no need for a vestigial extra+argument.++Join points always have at least one value argument,+for several reasons++* If we try to lift a primitive-typed something out+ for let-binding-purposes, we will *caseify* it (!),+ with potentially-disastrous strictness results. So+ instead we turn it into a function: \v -> e+ where v::Void#. The value passed to this function is void,+ which generates (almost) no code.++* CPR. We used to say "&& isUnliftedType rhs_ty'" here, but now+ we make the join point into a function whenever used_bndrs'+ is empty. This makes the join-point more CPR friendly.+ Consider: let j = if .. then I# 3 else I# 4+ in case .. of { A -> j; B -> j; C -> ... }++ Now CPR doesn't w/w j because it's a thunk, so+ that means that the enclosing function can't w/w either,+ which is a lose. Here's the example that happened in practice:+ kgmod :: Int -> Int -> Int+ kgmod x y = if x > 0 && y < 0 || x < 0 && y > 0+ then 78+ else 5++* Let-no-escape. We want a join point to turn into a let-no-escape+ so that it is implemented as a jump, and one of the conditions+ for LNE is that it's not updatable. In CoreToStg, see+ Note [What is a non-escaping let]++* Floating. Since a join point will be entered once, no sharing is+ gained by floating out, but something might be lost by doing+ so because it might be allocated.++I have seen a case alternative like this:+ True -> \v -> ...+It's a bit silly to add the realWorld dummy arg in this case, making+ $j = \s v -> ...+ True -> $j s+(the \v alone is enough to make CPR happy) but I think it's rare++There's a slight infelicity here: we pass the overall+case_bndr to all the join points if it's used in *any* RHS,+because we don't know its usage in each RHS separately++++************************************************************************+* *+ Unfoldings+* *+************************************************************************+-}++simplLetUnfolding :: SimplEnv-> TopLevelFlag+ -> Maybe SimplCont+ -> InId+ -> OutExpr+ -> Unfolding -> SimplM Unfolding+simplLetUnfolding env top_lvl cont_mb id new_rhs unf+ | isStableUnfolding unf+ = simplStableUnfolding env top_lvl cont_mb id unf+ | isExitJoinId id+ = return noUnfolding -- see Note [Do not inline exit join points]+ | otherwise+ = mkLetUnfolding (seDynFlags env) top_lvl InlineRhs id new_rhs++-------------------+mkLetUnfolding :: DynFlags -> TopLevelFlag -> UnfoldingSource+ -> InId -> OutExpr -> SimplM Unfolding+mkLetUnfolding dflags top_lvl src id new_rhs+ = is_bottoming `seq` -- See Note [Force bottoming field]+ return (mkUnfolding dflags src is_top_lvl is_bottoming new_rhs)+ -- We make an unfolding *even for loop-breakers*.+ -- Reason: (a) It might be useful to know that they are WHNF+ -- (b) In TidyPgm we currently assume that, if we want to+ -- expose the unfolding then indeed we *have* an unfolding+ -- to expose. (We could instead use the RHS, but currently+ -- we don't.) The simple thing is always to have one.+ where+ is_top_lvl = isTopLevel top_lvl+ is_bottoming = isBottomingId id++-------------------+simplStableUnfolding :: SimplEnv -> TopLevelFlag+ -> Maybe SimplCont -- Just k => a join point with continuation k+ -> InId+ -> Unfolding -> SimplM Unfolding+-- Note [Setting the new unfolding]+simplStableUnfolding env top_lvl mb_cont id unf+ = case unf of+ NoUnfolding -> return unf+ BootUnfolding -> return unf+ OtherCon {} -> return unf++ DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = args }+ -> do { (env', bndrs') <- simplBinders rule_env bndrs+ ; args' <- mapM (simplExpr env') args+ ; return (mkDFunUnfolding bndrs' con args') }++ CoreUnfolding { uf_tmpl = expr, uf_src = src, uf_guidance = guide }+ | isStableSource src+ -> do { expr' <- case mb_cont of+ Just cont -> simplJoinRhs rule_env id expr cont+ Nothing -> simplExpr rule_env expr+ ; case guide of+ UnfWhen { ug_arity = arity, ug_unsat_ok = sat_ok } -- Happens for INLINE things+ -> let guide' = UnfWhen { ug_arity = arity, ug_unsat_ok = sat_ok+ , ug_boring_ok = inlineBoringOk expr' }+ -- Refresh the boring-ok flag, in case expr'+ -- has got small. This happens, notably in the inlinings+ -- for dfuns for single-method classes; see+ -- Note [Single-method classes] in TcInstDcls.+ -- A test case is Trac #4138+ in return (mkCoreUnfolding src is_top_lvl expr' guide')+ -- See Note [Top-level flag on inline rules] in CoreUnfold++ _other -- Happens for INLINABLE things+ -> mkLetUnfolding dflags top_lvl src id expr' }+ -- If the guidance is UnfIfGoodArgs, this is an INLINABLE+ -- unfolding, and we need to make sure the guidance is kept up+ -- to date with respect to any changes in the unfolding.++ | otherwise -> return noUnfolding -- Discard unstable unfoldings+ where+ dflags = seDynFlags env+ is_top_lvl = isTopLevel top_lvl+ act = idInlineActivation id+ rule_env = updMode (updModeForStableUnfoldings act) env+ -- See Note [Simplifying inside stable unfoldings] in SimplUtils++{-+Note [Force bottoming field]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We need to force bottoming, or the new unfolding holds+on to the old unfolding (which is part of the id).++Note [Setting the new unfolding]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+* If there's an INLINE pragma, we simplify the RHS gently. Maybe we+ should do nothing at all, but simplifying gently might get rid of+ more crap.++* If not, we make an unfolding from the new RHS. But *only* for+ non-loop-breakers. Making loop breakers not have an unfolding at all+ means that we can avoid tests in exprIsConApp, for example. This is+ important: if exprIsConApp says 'yes' for a recursive thing, then we+ can get into an infinite loop++If there's a stable unfolding on a loop breaker (which happens for INLINABLE), we hang on to the inlining. It's pretty dodgy, but the user did say 'INLINE'. May need to revisit this choice.
simplStg/RepType.hs view
@@ -23,6 +23,8 @@ #include "HsVersions.h" +import GhcPrelude+ import BasicTypes (Arity, RepArity) import DataCon import Outputable@@ -155,7 +157,7 @@ -- has at least two disjuncts. But it could happen if a user writes, e.g., -- forall (a :: TYPE (SumRep [IntRep])). ... -- which could never be instantiated. We still don't want to panic.- | length constrs0 < 2+ | constrs0 `lengthLessThan` 2 = [WordSlot] | otherwise@@ -342,10 +344,6 @@ runtimeRepPrimRep doc runtime_rep kindPrimRep doc ki = pprPanic "kindPrimRep" (ppr ki $$ doc)-- -- TODO (RAE): Remove:- -- WARN( True, text "kindPrimRep defaulting to LiftedRep on" <+> ppr ki $$ doc )- -- [LiftedRep] -- this can happen legitimately for, e.g., Any -- | Take a type of kind RuntimeRep and extract the list of 'PrimRep' that -- it encodes.
simplStg/SimplStg.hs view
@@ -10,30 +10,27 @@ #include "HsVersions.h" +import GhcPrelude+ import StgSyn -import CostCentre ( CollectedCCs )-import SCCfinal ( stgMassageForProfiling ) import StgLint ( lintStgTopBindings ) import StgStats ( showStgStats ) import UnariseStg ( unarise ) import StgCse ( stgCse ) import DynFlags-import Module ( Module ) import ErrUtils import SrcLoc-import UniqSupply ( mkSplitUniqSupply, splitUniqSupply )+import UniqSupply ( mkSplitUniqSupply ) import Outputable import Control.Monad stg2stg :: DynFlags -- includes spec of what stg-to-stg passes to do- -> Module -- module name (profiling only) -> [StgTopBinding] -- input...- -> IO ( [StgTopBinding] -- output program...- , CollectedCCs) -- cost centre information (declared and used)+ -> IO [StgTopBinding] -- output program -stg2stg dflags module_name binds+stg2stg dflags binds = do { showPass dflags "Stg2Stg" ; us <- mkSplitUniqSupply 'g' @@ -41,62 +38,47 @@ (putLogMsg dflags NoReason SevDump noSrcSpan (defaultDumpStyle dflags) (text "VERBOSE STG-TO-STG:")) - ; (binds', us', ccs) <- end_pass us "Stg2Stg" ([],[],[]) binds+ ; binds' <- end_pass "Stg2Stg" binds -- Do the main business!- ; let (us0, us1) = splitUniqSupply us'- ; (processed_binds, _, cost_centres)- <- foldM do_stg_pass (binds', us0, ccs) (getStgToDo dflags)+ ; processed_binds <- foldM do_stg_pass binds' (getStgToDo dflags) ; dumpIfSet_dyn dflags Opt_D_dump_stg "Pre unarise:" (pprStgTopBindings processed_binds) - ; let un_binds = unarise us1 processed_binds+ ; let un_binds = stg_linter True "Unarise"+ $ unarise us processed_binds ; dumpIfSet_dyn dflags Opt_D_dump_stg "STG syntax:" (pprStgTopBindings un_binds) - ; return (un_binds, cost_centres)+ ; return un_binds } where- stg_linter = if gopt Opt_DoStgLinting dflags- then lintStgTopBindings- else ( \ _whodunnit binds -> binds )+ stg_linter unarised+ | gopt Opt_DoStgLinting dflags = lintStgTopBindings unarised+ | otherwise = \ _whodunnit binds -> binds -------------------------------------------- do_stg_pass (binds, us, ccs) to_do+ do_stg_pass binds to_do = case to_do of D_stg_stats -> trace (showStgStats binds)- end_pass us "StgStats" ccs binds-- StgDoMassageForProfiling ->- {-# SCC "ProfMassage" #-}- let- (us1, us2) = splitUniqSupply us- (collected_CCs, binds3)- = stgMassageForProfiling dflags module_name us1 binds- in- end_pass us2 "ProfMassage" collected_CCs binds3+ end_pass "StgStats" binds StgCSE -> {-# SCC "StgCse" #-} let binds' = stgCse binds in- end_pass us "StgCse" ccs binds'+ end_pass "StgCse" binds' - end_pass us2 what ccs binds2+ end_pass what binds2 = do -- report verbosely, if required dumpIfSet_dyn dflags Opt_D_verbose_stg2stg what (vcat (map ppr binds2))- let linted_binds = stg_linter what binds2- return (linted_binds, us2, ccs)- -- return: processed binds- -- UniqueSupply for the next guy to use- -- cost-centres to be declared/registered (specialised)- -- add to description of what's happened (reverse order)+ return (stg_linter False what binds2) -- ----------------------------------------------------------------------------- -- StgToDo: abstraction of stg-to-stg passes to run.@@ -104,14 +86,12 @@ -- | Optional Stg-to-Stg passes. data StgToDo = StgCSE- | StgDoMassageForProfiling -- should be (next to) last | D_stg_stats -- | Which optional Stg-to-Stg passes to run. Depends on flags, ways etc. getStgToDo :: DynFlags -> [StgToDo] getStgToDo dflags = [ StgCSE | gopt Opt_StgCSE dflags] ++- [ StgDoMassageForProfiling | WayProf `elem` ways dflags] ++ [ D_stg_stats | stg_stats ] where stg_stats = gopt Opt_StgStats dflags
simplStg/StgCse.hs view
@@ -5,9 +5,9 @@ ~~~~~~~~~~~~~~~~~~ This module implements a simple common subexpression elimination pass for STG. This is useful because there are expressions that we want to common up (because-they are operational equivalent), but that we cannot common up in Core, because+they are operationally equivalent), but that we cannot common up in Core, because their types differ.-This was original reported as #9291.+This was originally reported as #9291. There are two types of common code occurrences that we aim for, see note [Case 1: CSEing allocated closures] and@@ -16,7 +16,7 @@ Note [Case 1: CSEing allocated closures] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The fist kind of CSE opportunity we aim for is generated by this Haskell code:+The first kind of CSE opportunity we aim for is generated by this Haskell code: bar :: a -> (Either Int a, Either Bool a) bar x = (Right x, Right x)@@ -26,7 +26,7 @@ bar :: forall a. a -> (Either Int a, Either Bool a) bar @a x = (Right @Int @a x, Right @Bool @a x) -where the two components of the tuple are differnt terms, and cannot be+where the two components of the tuple are different terms, and cannot be commoned up (easily). On the STG level we have bar [x] = let c1 = Right [x]@@ -70,6 +70,8 @@ -} module StgCse (stgCse) where +import GhcPrelude+ import DataCon import Id import StgSyn@@ -137,7 +139,7 @@ -- * If we remove `let x = Con z` because `let y = Con z` is in scope, -- we note this here as x ↦ y. , ce_bndrMap :: IdEnv OutId- -- If we come across a case expression case x as b of … with a trivial+ -- ^ If we come across a case expression case x as b of … with a trivial -- binder, we add b ↦ x to this. -- This map is *only* used when looking something up in the ce_conAppMap. -- See Note [Trivial case scrutinee]@@ -217,7 +219,7 @@ -- Functions to enter binders --- This is much simpler than the requivalent code in CoreSubst:+-- This is much simpler than the equivalent code in CoreSubst: -- * We do not substitute type variables, and -- * There is nothing relevant in IdInfo at this stage -- that needs substitutions.@@ -293,7 +295,7 @@ = let body' = stgCseExpr env body in StgTick tick body' stgCseExpr env (StgCase scrut bndr ty alts)- = StgCase scrut' bndr' ty alts'+ = mkStgCase scrut' bndr' ty alts' where scrut' = stgCseExpr env scrut (env1, bndr') = substBndr env bndr@@ -362,7 +364,7 @@ mbCons = maybe id (:) -- The RHS of a binding.--- If it is an constructor application, either short-cut it or extend the environment+-- If it is a constructor application, either short-cut it or extend the environment stgCseRhs :: CseEnv -> OutId -> InStgRhs -> (Maybe (OutId, OutStgRhs), CseEnv) stgCseRhs env bndr (StgRhsCon ccs dataCon args) | Just other_bndr <- envLookup dataCon args' env@@ -381,6 +383,17 @@ in (Just (substVar env bndr, StgRhsClosure ccs info occs' upd args' body'), env) where occs' = substVars env occs ++mkStgCase :: StgExpr -> OutId -> AltType -> [StgAlt] -> StgExpr+mkStgCase scrut bndr ty alts | all isBndr alts = scrut+ | otherwise = StgCase scrut bndr ty alts++ where+ -- see Note [All alternatives are the binder]+ isBndr (_, _, StgApp f []) = f == bndr+ isBndr _ = False++ -- Utilities -- | This function short-cuts let-bindings that are now obsolete@@ -390,9 +403,27 @@ {-+Note [All alternatives are the binder]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++When all alternatives simply refer to the case binder, then we do not have+to bother with the case expression at all (#13588). CoreSTG does this as well,+but sometimes, types get into the way:++ newtype T = MkT Int+ f :: (Int, Int) -> (T, Int)+ f (x, y) = (MkT x, y)++Core cannot just turn this into++ f p = p++as this would not be well-typed. But to STG, where MkT is no longer in the way,+we can.+ Note [Trivial case scrutinee] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We wnat to be able to handle nested reconstruction of constructors as in+We want to be able to handle nested reconstruction of constructors as in nested :: Either Int (Either Int a) -> Either Bool (Either Bool a) nested (Right (Right v)) = Right (Right v)@@ -409,7 +440,7 @@ ce_conAppMap contains Right a! Therefore, we add r1 ↦ x to ce_bndrMap when analysing the outer case, and use-this subsitution before looking Right r2 up in ce_conAppMap, and everything+this substitution before looking Right r2 up in ce_conAppMap, and everything works out. Note [Free variables of an StgClosure]
simplStg/StgStats.hs view
@@ -27,6 +27,8 @@ #include "HsVersions.h" +import GhcPrelude+ import StgSyn import Id (Id)
simplStg/UnariseStg.hs view
@@ -196,6 +196,8 @@ #include "HsVersions.h" +import GhcPrelude+ import BasicTypes import CoreSyn import DataCon@@ -420,7 +422,7 @@ unariseAlts rho (MultiValAlt n) bndr [(DataAlt _, ys, e)] | isUnboxedTupleBndr bndr = do (rho', ys1) <- unariseConArgBinders rho ys- MASSERT(n == length ys1)+ MASSERT(ys1 `lengthIs` n) let rho'' = extendRho rho' bndr (MultiVal (map StgVarArg ys1)) e' <- unariseExpr rho'' e return [(DataAlt (tupleDataCon Unboxed n), ys1, e')]
specialise/Rules.hs view
@@ -28,6 +28,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn -- All of it import Module ( Module, ModuleSet, elemModuleSet ) import CoreSubst@@ -418,14 +420,13 @@ findBest target (rule1,ans1) ((rule2,ans2):prs) | rule1 `isMoreSpecific` rule2 = findBest target (rule1,ans1) prs | rule2 `isMoreSpecific` rule1 = findBest target (rule2,ans2) prs- | debugIsOn = let pp_rule rule = sdocWithPprDebug $ \dbg -> if dbg- then ppr rule- else doubleQuotes (ftext (ruleName rule))+ | debugIsOn = let pp_rule rule+ = ifPprDebug (ppr rule)+ (doubleQuotes (ftext (ruleName rule))) in pprTrace "Rules.findBest: rule overlap (Rule 1 wins)"- (vcat [ sdocWithPprDebug $ \dbg -> if dbg- then text "Expression to match:" <+> ppr fn- <+> sep (map ppr args)- else empty+ (vcat [ whenPprDebug $+ text "Expression to match:" <+> ppr fn+ <+> sep (map ppr args) , text "Rule 1:" <+> pp_rule rule1 , text "Rule 2:" <+> pp_rule rule2]) $ findBest target (rule1,ans1) prs@@ -582,7 +583,7 @@ = env unbound var = pprPanic "Template variable unbound in rewrite rule" $- vcat [ text "Variable:" <+> ppr var+ vcat [ text "Variable:" <+> ppr var <+> dcolon <+> ppr (varType var) , text "Rule" <+> pprRuleName rule_name , text "Rule bndrs:" <+> ppr tmpl_vars , text "LHS args:" <+> ppr tmpl_es@@ -617,7 +618,7 @@ RULE forall (c :: a~b). f (x |> c) = e Now, if that binding is inlined, so that a=b=Int, we'd get RULE forall (c :: Int~Int). f (x |> c) = e- and now when we simpilfy the LHS (Simplify.simplRule) we+ and now when we simplify the LHS (Simplify.simplRule) we optCoercion will turn that 'c' into Refl: RULE forall (c :: Int~Int). f (x |> <Int>) = e and then perhaps drop it altogether. Now 'c' is unbound.@@ -843,7 +844,7 @@ _ -> Nothing match_co _ _ _co1 _co2 -- Currently just deals with CoVarCo, TyConAppCo and Refl-#ifdef DEBUG+#if defined(DEBUG) = pprTrace "match_co: needs more cases" (ppr _co1 $$ ppr _co2) Nothing #else = Nothing
specialise/SpecConstr.hs view
@@ -19,6 +19,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreSubst import CoreUtils@@ -514,7 +516,7 @@ and not stored in ScEnv.) Trac #14379 turned out to be caused by f SPEC x = let g1 x = ... in ...-We force-specialise f (becuase of the SPEC), but that generates a specialised+We force-specialise f (because of the SPEC), but that generates a specialised copy of g1 (as well as the original). Alas g1 has a nested binding g2; and in each copy of g1 we get an unspecialised and specialised copy of g2; and so on. Result, exponential. So the force-spec flag now only applies to one@@ -524,7 +526,7 @@ - Switch it on at the call to specRec, in scExpr and scTopBinds - Switch it off when doing the RHSs;- this can be done very conveneniently in decreaseSpecCount+ this can be done very conveniently in decreaseSpecCount What alternatives did I consider? @@ -598,7 +600,7 @@ specialisations. If sc_count is "no limit" then we arbitrarily choose 10 as the limit (ugh). -See Trac #5550. Also Trac #13623, where this test had become over-agressive,+See Trac #5550. Also Trac #13623, where this test had become over-aggressive, and we lost a wonderful specialisation that we really wanted! Note [NoSpecConstr]@@ -1558,7 +1560,11 @@ return (usg_so_far, spec_infos) | otherwise- = do { specs_w_usg <- zipWithM (specialise env seed_calls) rhs_infos spec_infos+ = -- pprTrace "specRec3" (vcat [ text "bndrs" <+> ppr (map ri_fn rhs_infos)+ -- , text "iteration" <+> int n_iter+ -- , text "spec_infos" <+> ppr (map (map os_pat . si_specs) spec_infos)+ -- ]) $+ do { specs_w_usg <- zipWithM (specialise env seed_calls) rhs_infos spec_infos ; let (extra_usg_s, new_spec_infos) = unzip specs_w_usg extra_usg = combineUsages extra_usg_s all_usg = usg_so_far `combineUsage` extra_usg@@ -1781,7 +1787,7 @@ The caller can, indeed must, assume this. He should not combine in rhs_usg himself, or he'll get rhs_usg twice -- and that can lead to an exponential blowup of duplicates in the CallEnv. This is what gave rise to the massive-performace loss in Trac #8852.+performance loss in Trac #8852. Note [Specialise original body] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1805,7 +1811,7 @@ simplCore/should_compile/spec-inline. So now I just use the inline-activation of the parent Id, as the-activation for the specialiation RULE, just like the main specialiser;+activation for the specialisation RULE, just like the main specialiser; This in turn means there is no point in specialising NOINLINE things, so we test for that.@@ -1894,6 +1900,41 @@ * Otherwise we sort the patterns to choose the most general ones first; more general => more widely applicable.++Note [SpecConstr and casts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider (Trac #14270) a call like++ let f = e+ in ... f (K @(a |> co)) ...++where 'co' is a coercion variable not in scope at f's definition site.+If we aren't caereful we'll get++ let $sf a co = e (K @(a |> co))+ RULE "SC:f" forall a co. f (K @(a |> co)) = $sf a co+ f = e+ in ...++But alas, when we match the call we won't bind 'co', because type-matching+(for good reasons) discards casts).++I don't know how to solve this, so for now I'm just discarding any+call patterns that+ * Mentions a coercion variable+ * That is not in scope at the binding of the function++I think this is very rare.++Note that this /also/ discards the call pattern if we have a cast in a+/term/, although in fact Rules.match does make a very flaky and+fragile attempt to match coercions. e.g. a call like+ f (Maybe Age) (Nothing |> co) blah+ where co :: Maybe Int ~ Maybe Age+will be discarded. It's extremely fragile to match on the form of a+coercion, so I think it's better just not to try. A more complicated+alternative would be to discard calls that mention coercion variables+only in kind-casts, but I'm doing the simple thing for now. -} type CallPat = ([Var], [CoreExpr]) -- Quantified variables and arguments@@ -1931,7 +1972,8 @@ -- Discard specialisations if there are too many of them trimmed_pats = trim_pats env fn spec_info small_pats --- ; pprTrace "callsToPats" (vcat [ text "calls:" <+> ppr calls+-- ; pprTrace "callsToPats" (vcat [ text "calls to" <+> ppr fn <> colon <+> ppr calls+-- , text "done_specs:" <+> ppr (map os_pat done_specs) -- , text "good_pats:" <+> ppr good_pats ]) $ -- return () @@ -1944,7 +1986,8 @@ | sc_force env || isNothing mb_scc || n_remaining >= n_pats- = pats -- No need to trim+ = -- pprTrace "trim_pats: no-trim" (ppr (sc_force env) $$ ppr mb_scc $$ ppr n_remaining $$ ppr n_pats)+ pats -- No need to trim | otherwise = emit_trace $ -- Need to trim, so keep the best ones@@ -1965,8 +2008,8 @@ -- segment of this list pat_cons :: CallPat -> Int- -- How many data consturorst of literals are in- -- the patten. More data-cons => less general+ -- How many data constructors of literals are in+ -- the pattern. More data-cons => less general pat_cons (qs, ps) = foldr ((+) . n_cons) 0 ps where q_set = mkVarSet qs@@ -1988,6 +2031,8 @@ speakNOf spec_count' (text "call pattern") <> comma <+> text "but the limit is" <+> int max_specs) ] , text "Use -fspec-constr-count=n to set the bound"+ , text "done_spec_count =" <+> int done_spec_count+ , text "Keeping " <+> int n_remaining <> text ", out of" <+> int n_pats , text "Discarding:" <+> ppr (drop n_remaining sorted_pats) ] @@ -1996,8 +2041,8 @@ -- Type variables come first, since they may scope -- over the following term variables -- The [CoreExpr] are the argument patterns for the rule-callToPats env bndr_occs (Call _ args con_env)- | length args < length bndr_occs -- Check saturated+callToPats env bndr_occs call@(Call _ args con_env)+ | args `ltLength` bndr_occs -- Check saturated = return Nothing | otherwise = do { let in_scope = substInScope (sc_subst env)@@ -2025,8 +2070,13 @@ sanitise id = id `setIdType` expandTypeSynonyms (idType id) -- See Note [Free type variables of the qvar types] + bad_covars = filter isCoVar ids+ -- See Note [SpecConstr and casts]+ ; -- pprTrace "callToPats" (ppr args $$ ppr bndr_occs) $- if interesting+ WARN( not (null bad_covars), text "SpecConstr: bad covars:" <+> ppr bad_covars+ $$ ppr call )+ if interesting && null bad_covars then return (Just (qvars', pats)) else return Nothing }
specialise/Specialise.hs view
@@ -9,6 +9,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Id import TcType hiding( substTy ) import Type hiding( substTy, extendTvSubstList )@@ -43,9 +45,7 @@ import UniqDFM import Control.Monad-#if __GLASGOW_HASKELL__ > 710 import qualified Control.Monad.Fail as MonadFail-#endif {- ************************************************************************@@ -147,7 +147,7 @@ in fl -We still have recusion for non-overloaded functions which we+We still have recursion for non-overloaded functions which we specialise, but the recursive call should get specialised to the same recursive version. @@ -735,7 +735,7 @@ = do { warnMsg (vcat [ hang (text "Could not specialise imported function" <+> quotes (ppr fn)) 2 (vcat [ text "when specialising" <+> quotes (ppr caller) | caller <- callers])- , ifPprDebug (text "calls:" <+> vcat (map (pprCallInfo fn) calls_for_fn))+ , whenPprDebug (text "calls:" <+> vcat (map (pprCallInfo fn) calls_for_fn)) , text "Probable fix: add INLINABLE pragma on" <+> quotes (ppr fn) ]) ; return ([], []) } @@ -1304,7 +1304,7 @@ herald = case mb_mod of Nothing -- Specialising local fn -> text "SPEC"- Just this_mod -- Specialising imoprted fn+ Just this_mod -- Specialising imported fn -> text "SPEC/" <> ppr this_mod rule_name = mkFastString $ showSDoc dflags $@@ -1343,7 +1343,7 @@ -- See Note [Specialising imported functions] in OccurAnal | InlinePragma { inl_inline = Inlinable } <- inl_prag- = (inl_prag { inl_inline = EmptyInlineSpec }, noUnfolding)+ = (inl_prag { inl_inline = NoUserInline }, noUnfolding) | otherwise = (inl_prag, specUnfolding poly_tyvars spec_app@@ -1854,7 +1854,7 @@ when we come across the binding for $df. So we add $df to the floats and continue. But then we have to add $c== to the floats, and so on. These all float above the binding for 'f', and and now we can-successfullly specialise 'f'.+successfully specialise 'f'. So the DictBinds in (ud_binds :: Bag DictBind) may contain non-dictionary bindings too.@@ -2287,12 +2287,10 @@ case f y of SpecM z -> z- fail str = SpecM $ fail str+ fail = MonadFail.fail -#if __GLASGOW_HASKELL__ > 710 instance MonadFail.MonadFail SpecM where fail str = SpecM $ fail str-#endif instance MonadUnique SpecM where getUniqueSupplyM
stgSyn/CoreToStg.hs view
@@ -11,10 +11,12 @@ -- And, as we have the info in hand, we may convert some lets to -- let-no-escapes. -module CoreToStg ( coreToStg, coreExprToStg ) where+module CoreToStg ( coreToStg ) where #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreUtils ( exprType, findDefault, isJoinBind ) import CoreArity ( manifestArity )@@ -27,10 +29,10 @@ import Id import IdInfo import DataCon-import CostCentre ( noCCS )+import CostCentre import VarEnv import Module-import Name ( isExternalName, nameOccName )+import Name ( isExternalName, nameOccName, nameModule_maybe ) import OccName ( occNameFS ) import BasicTypes ( Arity ) import TysWiredIn ( unboxedUnitDataCon )@@ -44,6 +46,7 @@ import Demand ( isUsedOnce ) import PrimOp ( PrimCall(..) ) import UniqFM+import SrcLoc ( mkGeneralSrcSpan ) import Data.Maybe (isJust, fromMaybe) import Control.Monad (liftM, ap)@@ -194,61 +197,97 @@ -- in -- ...(x b)... +-- Note [Cost-centre initialization plan]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- Previously `coreToStg` was initializing cost-centre stack fields as `noCCS`,+-- and the fields were then fixed by a seperate pass `stgMassageForProfiling`.+-- We now initialize these correctly. The initialization works like this:+--+-- - For non-top level bindings always use `currentCCS`.+--+-- - For top-level bindings, check if the binding is a CAF+--+-- - CAF: If -fcaf-all is enabled, create a new CAF just for this CAF+-- and use it. Note that these new cost centres need to be+-- collected to be able to generate cost centre initialization+-- code, so `coreToTopStgRhs` now returns `CollectedCCs`.+--+-- If -fcaf-all is not enabled, use "all CAFs" cost centre.+--+-- - Non-CAF: Top-level (static) data is not counted in heap profiles; nor+-- do we set CCCS from it; so we just slam in+-- dontCareCostCentre.+ -- -------------------------------------------------------------- -- Setting variable info: top-level, binds, RHSs -- -------------------------------------------------------------- -coreToStg :: DynFlags -> Module -> CoreProgram -> [StgTopBinding]+coreToStg :: DynFlags -> Module -> CoreProgram+ -> ([StgTopBinding], CollectedCCs) coreToStg dflags this_mod pgm- = pgm'- where (_, _, pgm') = coreTopBindsToStg dflags this_mod emptyVarEnv pgm+ = (pgm', final_ccs)+ where+ (_, _, (local_ccs, local_cc_stacks), pgm')+ = coreTopBindsToStg dflags this_mod emptyVarEnv emptyCollectedCCs pgm -coreExprToStg :: CoreExpr -> StgExpr-coreExprToStg expr- = new_expr where (new_expr,_) = initCts emptyVarEnv (coreToStgExpr expr)+ prof = WayProf `elem` ways dflags + final_ccs+ | prof && gopt Opt_AutoSccsOnIndividualCafs dflags+ = (local_ccs,local_cc_stacks) -- don't need "all CAFs" CC+ | prof+ = (all_cafs_cc:local_ccs, all_cafs_ccs:local_cc_stacks)+ | otherwise+ = emptyCollectedCCs + (all_cafs_cc, all_cafs_ccs) = getAllCAFsCC this_mod+ coreTopBindsToStg :: DynFlags -> Module -> IdEnv HowBound -- environment for the bindings+ -> CollectedCCs -> CoreProgram- -> (IdEnv HowBound, FreeVarsInfo, [StgTopBinding])+ -> (IdEnv HowBound, FreeVarsInfo, CollectedCCs, [StgTopBinding]) -coreTopBindsToStg _ _ env [] = (env, emptyFVInfo, [])-coreTopBindsToStg dflags this_mod env (b:bs)- = (env2, fvs2, b':bs')+coreTopBindsToStg _ _ env ccs []+ = (env, emptyFVInfo, ccs, [])+coreTopBindsToStg dflags this_mod env ccs (b:bs)+ = (env2, fvs2, ccs2, b':bs') where -- Notice the mutually-recursive "knot" here: -- env accumulates down the list of binds, -- fvs accumulates upwards- (env1, fvs2, b' ) = coreTopBindToStg dflags this_mod env fvs1 b- (env2, fvs1, bs') = coreTopBindsToStg dflags this_mod env1 bs+ (env1, fvs2, ccs1, b' ) =+ coreTopBindToStg dflags this_mod env fvs1 ccs b+ (env2, fvs1, ccs2, bs') =+ coreTopBindsToStg dflags this_mod env1 ccs1 bs coreTopBindToStg :: DynFlags -> Module -> IdEnv HowBound -> FreeVarsInfo -- Info about the body+ -> CollectedCCs -> CoreBind- -> (IdEnv HowBound, FreeVarsInfo, StgTopBinding)+ -> (IdEnv HowBound, FreeVarsInfo, CollectedCCs, StgTopBinding) -coreTopBindToStg _ _ env body_fvs (NonRec id (Lit (MachStr str)))+coreTopBindToStg _ _ env body_fvs ccs (NonRec id (Lit (MachStr str))) -- top-level string literal = let env' = extendVarEnv env id how_bound how_bound = LetBound TopLet 0- in (env', body_fvs, StgTopStringLit id str)+ in (env', body_fvs, ccs, StgTopStringLit id str) -coreTopBindToStg dflags this_mod env body_fvs (NonRec id rhs)+coreTopBindToStg dflags this_mod env body_fvs ccs (NonRec id rhs) = let env' = extendVarEnv env id how_bound how_bound = LetBound TopLet $! manifestArity rhs - (stg_rhs, fvs') =- initCts env $ do- (stg_rhs, fvs') <- coreToTopStgRhs dflags this_mod body_fvs (id,rhs)- return (stg_rhs, fvs')+ (stg_rhs, fvs', ccs') =+ initCts env $+ coreToTopStgRhs dflags ccs this_mod body_fvs (id,rhs) bind = StgTopLifted $ StgNonRec id stg_rhs in@@ -257,9 +296,9 @@ -- as well as 'id', but that led to a black hole -- where printing the assertion error tripped the -- assertion again!- (env', fvs' `unionFVInfo` body_fvs, bind)+ (env', fvs' `unionFVInfo` body_fvs, ccs', bind) -coreTopBindToStg dflags this_mod env body_fvs (Rec pairs)+coreTopBindToStg dflags this_mod env body_fvs ccs (Rec pairs) = ASSERT( not (null pairs) ) let binders = map fst pairs@@ -268,16 +307,21 @@ | (b, rhs) <- pairs ] env' = extendVarEnvList env extra_env' - (stg_rhss, fvs')+ -- generate StgTopBindings, accumulate body_fvs and CAF cost centres+ -- created for CAFs+ ((fvs', ccs'), stg_rhss) = initCts env' $ do- (stg_rhss, fvss') <- mapAndUnzipM (coreToTopStgRhs dflags this_mod body_fvs) pairs- let fvs' = unionFVInfos fvss'- return (stg_rhss, fvs')+ mapAccumLM (\(fvs, ccs) rhs -> do+ (rhs', fvs', ccs') <-+ coreToTopStgRhs dflags ccs this_mod body_fvs rhs+ return ((fvs' `unionFVInfo` fvs, ccs'), rhs'))+ (body_fvs, ccs)+ pairs bind = StgTopLifted $ StgRec (zip binders stg_rhss) in ASSERT2(consistentCafInfo (head binders) bind, ppr binders)- (env', fvs' `unionFVInfo` body_fvs, bind)+ (env', fvs' `unionFVInfo` body_fvs, ccs', bind) -- Assertion helper: this checks that the CafInfo on the Id matches@@ -297,18 +341,23 @@ coreToTopStgRhs :: DynFlags+ -> CollectedCCs -> Module -> FreeVarsInfo -- Free var info for the scope of the binding -> (Id,CoreExpr)- -> CtsM (StgRhs, FreeVarsInfo)+ -> CtsM (StgRhs, FreeVarsInfo, CollectedCCs) -coreToTopStgRhs dflags this_mod scope_fv_info (bndr, rhs)+coreToTopStgRhs dflags ccs this_mod scope_fv_info (bndr, rhs) = do { (new_rhs, rhs_fvs) <- coreToStgExpr rhs - ; let stg_rhs = mkTopStgRhs dflags this_mod rhs_fvs bndr bndr_info new_rhs- stg_arity = stgRhsArity stg_rhs+ ; let (stg_rhs, ccs') =+ mkTopStgRhs dflags this_mod ccs rhs_fvs bndr bndr_info new_rhs+ stg_arity =+ stgRhsArity stg_rhs+ ; return (ASSERT2( arity_ok stg_arity, mk_arity_msg stg_arity) stg_rhs,- rhs_fvs) }+ rhs_fvs,+ ccs') } where bndr_info = lookupFVInfo scope_fv_info bndr @@ -331,14 +380,6 @@ text "Id arity:" <+> ppr id_arity, text "STG arity:" <+> ppr stg_arity] -mkTopStgRhs :: DynFlags -> Module -> FreeVarsInfo- -> Id -> StgBinderInfo -> StgExpr- -> StgRhs--mkTopStgRhs dflags this_mod = mkStgRhs' con_updateable- -- Dynamic StgConApps are updatable- where con_updateable con args = isDllConApp dflags this_mod con args- -- --------------------------------------------------------------------------- -- Expressions -- ---------------------------------------------------------------------------@@ -718,41 +759,91 @@ where bndr_info = lookupFVInfo scope_fv_info bndr -mkStgRhs :: FreeVarsInfo -> Id -> StgBinderInfo -> StgExpr -> StgRhs-mkStgRhs = mkStgRhs' con_updateable- where con_updateable _ _ = False+-- Generate a top-level RHS. Any new cost centres generated for CAFs will be+-- appended to `CollectedCCs` argument.+mkTopStgRhs :: DynFlags -> Module -> CollectedCCs+ -> FreeVarsInfo -> Id -> StgBinderInfo -> StgExpr+ -> (StgRhs, CollectedCCs) -mkStgRhs' :: (DataCon -> [StgArg] -> Bool)- -> FreeVarsInfo -> Id -> StgBinderInfo -> StgExpr -> StgRhs-mkStgRhs' con_updateable rhs_fvs bndr binder_info rhs+mkTopStgRhs dflags this_mod ccs rhs_fvs bndr binder_info rhs | StgLam bndrs body <- rhs- = StgRhsClosure noCCS binder_info- (getFVs rhs_fvs)- ReEntrant- bndrs body- | isJoinId bndr -- must be nullary join point- = ASSERT(idJoinArity bndr == 0)- StgRhsClosure noCCS binder_info- (getFVs rhs_fvs)- ReEntrant -- ignored for LNE- [] rhs+ = -- StgLam can't have empty arguments, so not CAF+ ASSERT(not (null bndrs))+ ( StgRhsClosure dontCareCCS binder_info+ (getFVs rhs_fvs)+ ReEntrant+ bndrs body+ , ccs )+ | StgConApp con args _ <- unticked_rhs- , not (con_updateable con args)+ , -- Dynamic StgConApps are updatable+ not (isDllConApp dflags this_mod con args) = -- CorePrep does this right, but just to make sure ASSERT2( not (isUnboxedTupleCon con || isUnboxedSumCon con) , ppr bndr $$ ppr con $$ ppr args)- StgRhsCon noCCS con args+ ( StgRhsCon dontCareCCS con args, ccs )++ -- Otherwise it's a CAF, see Note [Cost-centre initialization plan].+ | gopt Opt_AutoSccsOnIndividualCafs dflags+ = ( StgRhsClosure caf_ccs binder_info+ (getFVs rhs_fvs)+ upd_flag [] rhs+ , collectCC caf_cc caf_ccs ccs )+ | otherwise- = StgRhsClosure noCCS binder_info- (getFVs rhs_fvs)- upd_flag [] rhs- where+ = ( StgRhsClosure all_cafs_ccs binder_info+ (getFVs rhs_fvs)+ upd_flag [] rhs+ , ccs ) + where (_, unticked_rhs) = stripStgTicksTop (not . tickishIsCode) rhs upd_flag | isUsedOnce (idDemandInfo bndr) = SingleEntry | otherwise = Updatable + -- CAF cost centres generated for -fcaf-all+ caf_cc = mkAutoCC bndr modl CafCC+ caf_ccs = mkSingletonCCS caf_cc+ -- careful: the binder might be :Main.main,+ -- which doesn't belong to module mod_name.+ -- bug #249, tests prof001, prof002+ modl | Just m <- nameModule_maybe (idName bndr) = m+ | otherwise = this_mod++ -- default CAF cost centre+ (_, all_cafs_ccs) = getAllCAFsCC this_mod++-- Generate a non-top-level RHS. Cost-centre is always currentCCS,+-- see Note [Cost-centre initialzation plan].+mkStgRhs :: FreeVarsInfo -> Id -> StgBinderInfo -> StgExpr -> StgRhs+mkStgRhs rhs_fvs bndr binder_info rhs+ | StgLam bndrs body <- rhs+ = StgRhsClosure currentCCS binder_info+ (getFVs rhs_fvs)+ ReEntrant+ bndrs body++ | isJoinId bndr -- must be a nullary join point+ = ASSERT(idJoinArity bndr == 0)+ StgRhsClosure currentCCS binder_info+ (getFVs rhs_fvs)+ ReEntrant -- ignored for LNE+ [] rhs++ | StgConApp con args _ <- unticked_rhs+ = StgRhsCon currentCCS con args++ | otherwise+ = StgRhsClosure currentCCS binder_info+ (getFVs rhs_fvs)+ upd_flag [] rhs+ where+ (_, unticked_rhs) = stripStgTicksTop (not . tickishIsCode) rhs++ upd_flag | isUsedOnce (idDemandInfo bndr) = SingleEntry+ | otherwise = Updatable+ {- SDM: disabled. Eval/Apply can't handle functions with arity zero very well; and making these into simple non-updatable thunks breaks other@@ -903,6 +994,14 @@ Just xx -> xx Nothing -> ASSERT2( isGlobalId v, ppr v ) ImportBound +getAllCAFsCC :: Module -> (CostCentre, CostCentreStack)+getAllCAFsCC this_mod =+ let+ span = mkGeneralSrcSpan (mkFastString "<entire-module>") -- XXX do better+ all_cafs_cc = mkAllCafsCC this_mod span+ all_cafs_ccs = mkSingletonCCS all_cafs_cc+ in+ (all_cafs_cc, all_cafs_ccs) -- --------------------------------------------------------------------------- -- Free variable information
stgSyn/StgLint.hs view
@@ -8,10 +8,12 @@ module StgLint ( lintStgTopBindings ) where +import GhcPrelude+ import StgSyn import Bag ( Bag, emptyBag, isEmptyBag, snocBag, bagToList )-import Id ( Id, idType, isLocalId )+import Id ( Id, idType, isLocalId, isJoinId ) import VarSet import DataCon import CoreSyn ( AltCon(..) )@@ -56,11 +58,12 @@ @lintStgTopBindings@ is the top-level interface function. -} -lintStgTopBindings :: String -> [StgTopBinding] -> [StgTopBinding]+lintStgTopBindings :: Bool -- ^ have we run Unarise yet?+ -> String -> [StgTopBinding] -> [StgTopBinding] -lintStgTopBindings whodunnit binds+lintStgTopBindings unarised whodunnit binds = {-# SCC "StgLint" #-}- case (initL (lint_binds binds)) of+ case (initL unarised (lint_binds binds)) of Nothing -> binds Just msg -> pprPanic "" (vcat [ text "*** Stg Lint ErrMsgs: in" <+>@@ -108,7 +111,7 @@ _maybe_rhs_ty <- lintStgRhs rhs -- Check binder doesn't have unlifted type- checkL (not (isUnliftedType binder_ty))+ checkL (isJoinId binder || not (isUnliftedType binder_ty)) (mkUnliftedTyMsg binder rhs) -- Check match to RHS type@@ -196,11 +199,16 @@ lintStgExpr (StgCase scrut bndr alts_type alts) = runMaybeT $ do _ <- MaybeT $ lintStgExpr scrut + lf <- liftMaybeT getLintFlags in_scope <- MaybeT $ liftM Just $ case alts_type of AlgAlt tc -> check_bndr (tyConPrimRep tc) >> return True PrimAlt rep -> check_bndr [rep] >> return True- MultiValAlt _ -> return False -- Binder is always dead in this case+ -- Case binders of unboxed tuple or unboxed sum type always dead+ -- after the unariser has run. See Note [Post-unarisation invariants].+ MultiValAlt _+ | lf_unarised lf -> return False+ | otherwise -> return True PolyAlt -> return True MaybeT $ addInScopeVars [bndr | in_scope] $@@ -248,7 +256,7 @@ -- This does not work for existential constructors checkL (con `elem` cons) (mkAlgAltMsg2 scrut_ty con)- checkL (length args == dataConRepArity con) (mkAlgAltMsg3 con args)+ checkL (args `lengthIs` dataConRepArity con) (mkAlgAltMsg3 con args) when (isVanillaDataCon con) $ mapM_ check (zipEqual "lintAlgAlt:stg" arg_tys args) return ()@@ -275,12 +283,17 @@ -} newtype LintM a = LintM- { unLintM :: [LintLocInfo] -- Locations+ { unLintM :: LintFlags+ -> [LintLocInfo] -- Locations -> IdSet -- Local vars in scope -> Bag MsgDoc -- Error messages so far -> (a, Bag MsgDoc) -- Result and error messages (if any) } +data LintFlags = LintFlags { lf_unarised :: !Bool+ -- ^ have we run the unariser yet?+ }+ data LintLocInfo = RhsOf Id -- The variable bound | LambdaBodyOf [Id] -- The lambda-binder@@ -303,20 +316,22 @@ pp_binder b = hsep [ppr b, dcolon, ppr (idType b)] -initL :: LintM a -> Maybe MsgDoc-initL (LintM m)- = case (m [] emptyVarSet emptyBag) of { (_, errs) ->+initL :: Bool -> LintM a -> Maybe MsgDoc+initL unarised (LintM m)+ = case (m lf [] emptyVarSet emptyBag) of { (_, errs) -> if isEmptyBag errs then Nothing else Just (vcat (punctuate blankLine (bagToList errs))) }+ where+ lf = LintFlags unarised instance Functor LintM where fmap = liftM instance Applicative LintM where- pure a = LintM $ \_loc _scope errs -> (a, errs)+ pure a = LintM $ \_lf _loc _scope errs -> (a, errs) (<*>) = ap (*>) = thenL_ @@ -325,21 +340,21 @@ (>>) = (*>) thenL :: LintM a -> (a -> LintM b) -> LintM b-thenL m k = LintM $ \loc scope errs- -> case unLintM m loc scope errs of- (r, errs') -> unLintM (k r) loc scope errs'+thenL m k = LintM $ \lf loc scope errs+ -> case unLintM m lf loc scope errs of+ (r, errs') -> unLintM (k r) lf loc scope errs' thenL_ :: LintM a -> LintM b -> LintM b-thenL_ m k = LintM $ \loc scope errs- -> case unLintM m loc scope errs of- (_, errs') -> unLintM k loc scope errs'+thenL_ m k = LintM $ \lf loc scope errs+ -> case unLintM m lf loc scope errs of+ (_, errs') -> unLintM k lf loc scope errs' checkL :: Bool -> MsgDoc -> LintM () checkL True _ = return () checkL False msg = addErrL msg addErrL :: MsgDoc -> LintM ()-addErrL msg = LintM $ \loc _scope errs -> ((), addErr errs msg loc)+addErrL msg = LintM $ \_lf loc _scope errs -> ((), addErr errs msg loc) addErr :: Bag MsgDoc -> MsgDoc -> [LintLocInfo] -> Bag MsgDoc addErr errs_so_far msg locs@@ -350,15 +365,18 @@ mk_msg [] = msg addLoc :: LintLocInfo -> LintM a -> LintM a-addLoc extra_loc m = LintM $ \loc scope errs- -> unLintM m (extra_loc:loc) scope errs+addLoc extra_loc m = LintM $ \lf loc scope errs+ -> unLintM m lf (extra_loc:loc) scope errs addInScopeVars :: [Id] -> LintM a -> LintM a-addInScopeVars ids m = LintM $ \loc scope errs+addInScopeVars ids m = LintM $ \lf loc scope errs -> let new_set = mkVarSet ids- in unLintM m loc (scope `unionVarSet` new_set) errs+ in unLintM m lf loc (scope `unionVarSet` new_set) errs +getLintFlags :: LintM LintFlags+getLintFlags = LintM $ \lf _loc _scope errs -> (lf, errs)+ {- Checking function applications: we only check that the type has the right *number* of arrows, we don't actually compare the types. This@@ -397,7 +415,7 @@ | Just (tc,tc_args) <- splitTyConApp_maybe fun_ty , isNewTyCon tc- = if length tc_args < tyConArity tc+ = if tc_args `lengthLessThan` tyConArity tc then WARN( True, text "cfa: unsaturated newtype" <+> ppr fun_ty $$ msg ) (Nothing, Nothing) -- This is odd, but I've seen it else cfa False (newTyConInstRhs tc tc_args) arg_tys@@ -409,62 +427,27 @@ | otherwise = (Nothing, Nothing) +-- | "Compare" types. We used to try a crude comparison of the type themselves,+-- but this is essentially impossible in STG as we have discarded both casts+-- and type applications, so types might look different but be the same. Now we+-- simply compare their runtime representations. See #14120. stgEqType :: Type -> Type -> Bool--- Compare types, but crudely because we have discarded--- both casts and type applications, so types might look--- different but be the same. So reply "True" if in doubt.--- "False" means that the types are definitely different.------ Fundamentally this is a losing battle because of unsafeCoerce--stgEqType orig_ty1 orig_ty2- = gos orig_ty1 orig_ty2+stgEqType ty1 ty2+ = reps1 == reps2 where- gos :: Type -> Type -> Bool- gos ty1 ty2- -- These have no prim rep- | isRuntimeRepKindedTy ty1 && isRuntimeRepKindedTy ty2- = True-- -- We have a unary type- | [_] <- reps1, [_] <- reps2- = go ty1 ty2-- -- In the case of a tuple just compare prim reps- | otherwise- = reps1 == reps2- where- reps1 = typePrimRep ty1- reps2 = typePrimRep ty2-- go :: UnaryType -> UnaryType -> Bool- go ty1 ty2- | Just (tc1, tc_args1) <- splitTyConApp_maybe ty1- , Just (tc2, tc_args2) <- splitTyConApp_maybe ty2- , let res = if tc1 == tc2- then equalLength tc_args1 tc_args2- && and (zipWith gos tc_args1 tc_args2)- else -- TyCons don't match; but don't bleat if either is a- -- family TyCon because a coercion might have made it- -- equal to something else- (isFamilyTyCon tc1 || isFamilyTyCon tc2)- = if res then True- else- pprTrace "stgEqType: unequal" (vcat [ppr ty1, ppr ty2])- False-- | otherwise = True -- Conservatively say "fine".- -- Type variables in particular+ reps1 = typePrimRep ty1+ reps2 = typePrimRep ty2 checkInScope :: Id -> LintM ()-checkInScope id = LintM $ \loc scope errs+checkInScope id = LintM $ \_lf loc scope errs -> if isLocalId id && not (id `elemVarSet` scope) then- ((), addErr errs (hsep [ppr id, text "is out of scope"]) loc)+ ((), addErr errs (hsep [ppr id, dcolon, ppr (idType id),+ text "is out of scope"]) loc) else ((), errs) checkTys :: Type -> Type -> MsgDoc -> LintM ()-checkTys ty1 ty2 msg = LintM $ \loc _scope errs+checkTys ty1 ty2 msg = LintM $ \_lf loc _scope errs -> if (ty1 `stgEqType` ty2) then ((), errs) else ((), addErr errs msg loc)@@ -509,7 +492,7 @@ mkAlgAltMsg3 con alts = vcat [ text "In some algebraic case alternative, number of arguments doesn't match constructor:",- ppr con,+ ppr con <+> parens (text "arity" <+> ppr (dataConRepArity con)), ppr alts ]
stgSyn/StgSyn.hs view
@@ -45,6 +45,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn ( AltCon, Tickish ) import CostCentre ( CostCentreStack ) import Data.ByteString ( ByteString )@@ -665,8 +667,8 @@ 4 (ppr rhs <> semi) pprGenStgBinding (StgRec pairs)- = vcat $ ifPprDebug (text "{- StgRec (begin) -}") :- map (ppr_bind) pairs ++ [ifPprDebug (text "{- StgRec (end) -}")]+ = vcat $ whenPprDebug (text "{- StgRec (begin) -}") :+ map (ppr_bind) pairs ++ [whenPprDebug (text "{- StgRec (end) -}")] where ppr_bind (bndr, expr) = hang (hsep [pprBndr LetBind bndr, equals])@@ -738,7 +740,7 @@ (hang (hcat [text "let { ", ppr bndr, ptext (sLit " = "), ppr cc, pp_binder_info bi,- text " [", ifPprDebug (interppSP free_vars), ptext (sLit "] \\"),+ text " [", whenPprDebug (interppSP free_vars), ptext (sLit "] \\"), ppr upd_flag, text " [", interppSP args, char ']']) 8 (sep [hsep [ppr rhs, text "} in"]]))@@ -774,7 +776,7 @@ pprStgExpr (StgCase expr bndr alt_type alts) = sep [sep [text "case", nest 4 (hsep [pprStgExpr expr,- ifPprDebug (dcolon <+> ppr alt_type)]),+ whenPprDebug (dcolon <+> ppr alt_type)]), text "of", pprBndr CaseBind bndr, char '{'], nest 2 (vcat (map pprStgAlt alts)), char '}']@@ -801,9 +803,11 @@ -- special case pprStgRhs (StgRhsClosure cc bi [free_var] upd_flag [{-no args-}] (StgApp func []))- = hsep [ ppr cc,+ = sdocWithDynFlags $ \dflags ->+ hsep [ ppr cc, pp_binder_info bi,- brackets (ifPprDebug (ppr free_var)),+ if not $ gopt Opt_SuppressStgFreeVars dflags+ then brackets (ppr free_var) else empty, text " \\", ppr upd_flag, ptext (sLit " [] "), ppr func ] -- general case@@ -811,7 +815,8 @@ = sdocWithDynFlags $ \dflags -> hang (hsep [if gopt Opt_SccProfilingOn dflags then ppr cc else empty, pp_binder_info bi,- ifPprDebug (brackets (interppSP free_vars)),+ if not $ gopt Opt_SuppressStgFreeVars dflags+ then brackets (interppSP free_vars) else empty, char '\\' <> ppr upd_flag, brackets (interppSP args)]) 4 (ppr body)
stranal/DmdAnal.hs view
@@ -13,6 +13,8 @@ #include "HsVersions.h" +import GhcPrelude+ import DynFlags import WwLib ( findTypeShape, deepSplitProductType_maybe ) import Demand -- All of it@@ -64,20 +66,20 @@ dmdAnalTopBind :: AnalEnv -> CoreBind -> (AnalEnv, CoreBind)-dmdAnalTopBind sigs (NonRec id rhs)- = (extendAnalEnv TopLevel sigs id2 (idStrictness id2), NonRec id2 rhs2)+dmdAnalTopBind env (NonRec id rhs)+ = (extendAnalEnv TopLevel env id2 (idStrictness id2), NonRec id2 rhs2) where- ( _, _, rhs1) = dmdAnalRhsLetDown TopLevel Nothing sigs id rhs- ( _, id2, rhs2) = dmdAnalRhsLetDown TopLevel Nothing (nonVirgin sigs) id rhs1+ ( _, _, rhs1) = dmdAnalRhsLetDown TopLevel Nothing env cleanEvalDmd id rhs+ ( _, id2, rhs2) = dmdAnalRhsLetDown TopLevel Nothing (nonVirgin env) cleanEvalDmd id rhs1 -- Do two passes to improve CPR information -- See Note [CPR for thunks] -- See Note [Optimistic CPR in the "virgin" case] -- See Note [Initial CPR for strict binders] -dmdAnalTopBind sigs (Rec pairs)- = (sigs', Rec pairs')+dmdAnalTopBind env (Rec pairs)+ = (env', Rec pairs') where- (sigs', _, pairs') = dmdFix TopLevel sigs pairs+ (env', _, pairs') = dmdFix TopLevel env cleanEvalDmd pairs -- We get two iterations automatically -- c.f. the NonRec case above @@ -90,6 +92,9 @@ seqBinds over the output before returning it, to ensure that there are no references holding on to the input Core program. +This makes a ~30% reduction in peak memory usage when compiling+DynFlags (cf Trac #9675 and #13426).+ This is particularly important when we are doing late demand analysis, since we don't do a seqBinds at any point thereafter. Hence code generation would hold on to an extra copy of the Core program, via@@ -305,11 +310,11 @@ dmdAnal' env dmd (Let (NonRec id rhs) body) = (body_ty2, Let (NonRec id2 rhs') body') where- (lazy_fv, id1, rhs') = dmdAnalRhsLetDown NotTopLevel Nothing env id rhs+ (lazy_fv, id1, rhs') = dmdAnalRhsLetDown NotTopLevel Nothing env dmd id rhs env1 = extendAnalEnv NotTopLevel env id1 (idStrictness id1) (body_ty, body') = dmdAnal env1 dmd body (body_ty1, id2) = annotateBndr env body_ty id1- body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleasheable free variables]+ body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleashable free variables] -- If the actual demand is better than the vanilla call -- demand, you might think that we might do better to re-analyse@@ -326,10 +331,10 @@ dmdAnal' env dmd (Let (Rec pairs) body) = let- (env', lazy_fv, pairs') = dmdFix NotTopLevel env pairs+ (env', lazy_fv, pairs') = dmdFix NotTopLevel env dmd pairs (body_ty, body') = dmdAnal env' dmd body body_ty1 = deleteFVs body_ty (map fst pairs)- body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleasheable free variables]+ body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleashable free variables] in body_ty2 `seq` (body_ty2, Let (Rec pairs') body')@@ -396,7 +401,7 @@ So if the scrutinee is a primop call, we *don't* apply the state hack:- - If is a simple, terminating one like getMaskingState,+ - If it is a simple, terminating one like getMaskingState, applying the hack is over-conservative. - If the primop is raise# then it returns bottom, so the case alternatives are already discarded.@@ -506,17 +511,17 @@ -- Recursive bindings dmdFix :: TopLevelFlag -> AnalEnv -- Does not include bindings for this binding+ -> CleanDemand -> [(Id,CoreExpr)] -> (AnalEnv, DmdEnv, [(Id,CoreExpr)]) -- Binders annotated with stricness info -dmdFix top_lvl env orig_pairs+dmdFix top_lvl env let_dmd orig_pairs = loop 1 initial_pairs where bndrs = map fst orig_pairs -- See Note [Initialising strictness] initial_pairs | ae_virgin env = [(setIdStrictness id botSig, rhs) | (id, rhs) <- orig_pairs ]- | otherwise = orig_pairs -- If fixed-point iteration does not yield a result we use this instead@@ -524,7 +529,7 @@ abort :: (AnalEnv, DmdEnv, [(Id,CoreExpr)]) abort = (env, lazy_fv', zapped_pairs) where (lazy_fv, pairs') = step True (zapIdStrictness orig_pairs)- -- Note [Lazy and unleasheable free variables]+ -- Note [Lazy and unleashable free variables] non_lazy_fvs = plusVarEnvList $ map (strictSigDmdEnv . idStrictness . fst) pairs' lazy_fv' = lazy_fv `plusVarEnv` mapVarEnv (const topDmd) non_lazy_fvs zapped_pairs = zapIdStrictness pairs'@@ -559,7 +564,7 @@ my_downRhs (env, lazy_fv) (id,rhs) = ((env', lazy_fv'), (id', rhs')) where- (lazy_fv1, id', rhs') = dmdAnalRhsLetDown top_lvl (Just bndrs) env id rhs+ (lazy_fv1, id', rhs') = dmdAnalRhsLetDown top_lvl (Just bndrs) env let_dmd id rhs lazy_fv' = plusVarEnv_C bothDmd lazy_fv lazy_fv1 env' = extendAnalEnv top_lvl env id (idStrictness id') @@ -576,7 +581,7 @@ round, for two reasons: * To get information on used free variables (both lazy and strict!)- (see Note [Lazy and unleasheable free variables])+ (see Note [Lazy and unleashable free variables]) * To ensure that all expressions have been traversed at least once, and any left-over strictness annotations have been updated. @@ -618,18 +623,27 @@ -- This is the LetDown rule in the paper “Higher-Order Cardinality Analysis”. dmdAnalRhsLetDown :: TopLevelFlag -> Maybe [Id] -- Just bs <=> recursive, Nothing <=> non-recursive- -> AnalEnv -> Id -> CoreExpr+ -> AnalEnv -> CleanDemand+ -> Id -> CoreExpr -> (DmdEnv, Id, CoreExpr) -- Process the RHS of the binding, add the strictness signature -- to the Id, and augment the environment with the signature as well.-dmdAnalRhsLetDown top_lvl rec_flag env id rhs+dmdAnalRhsLetDown top_lvl rec_flag env let_dmd id rhs | Just fn <- unpackTrivial rhs -- See Note [Demand analysis for trivial right-hand sides] = dmdAnalTrivialRhs env id rhs fn | otherwise = (lazy_fv, id', mkLams bndrs' body') where- (bndrs, body) = collectBinders rhs+ (bndrs, body, body_dmd)+ = case isJoinId_maybe id of+ Just join_arity -- See Note [Demand analysis for join points]+ | (bndrs, body) <- collectNBinders join_arity rhs+ -> (bndrs, body, let_dmd)++ Nothing | (bndrs, body) <- collectBinders rhs+ -> (bndrs, body, mkBodyDmd env body)+ env_body = foldl extendSigsWithLam env bndrs (body_ty, body') = dmdAnal env_body body_dmd body body_ty' = removeDmdTyArgs body_ty -- zap possible deep CPR info@@ -639,10 +653,6 @@ id' = set_idStrictness env id sig_ty -- See Note [NOINLINE and strictness] - -- See Note [Product demands for function body]- body_dmd = case deepSplitProductType_maybe (ae_fam_envs env) (exprType body) of- Nothing -> cleanEvalDmd- Just (dc, _, _, _) -> cleanEvalProdDmd (dataConRepArity dc) -- See Note [Aggregated demand for cardinality] rhs_fv1 = case rec_flag of@@ -664,6 +674,13 @@ || not (isStrictDmd (idDemandInfo id) || ae_virgin env) -- See Note [Optimistic CPR in the "virgin" case] +mkBodyDmd :: AnalEnv -> CoreExpr -> CleanDemand+-- See Note [Product demands for function body]+mkBodyDmd env body+ = case deepSplitProductType_maybe (ae_fam_envs env) (exprType body) of+ Nothing -> cleanEvalDmd+ Just (dc, _, _, _) -> cleanEvalProdDmd (dataConRepArity dc)+ unpackTrivial :: CoreExpr -> Maybe Id -- Returns (Just v) if the arg is really equal to v, modulo -- casts, type applications etc@@ -688,7 +705,37 @@ useLetUp _ _ = True -{-+{- Note [Demand analysis for join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ g :: (Int,Int) -> Int+ g (p,q) = p+q++ f :: T -> Int -> Int+ f x p = g (join j y = (p,y)+ in case x of+ A -> j 3+ B -> j 4+ C -> (p,7))++If j was a vanilla function definition, we'd analyse its body with+evalDmd, and think that it was lazy in p. But for join points we can+do better! We know that j's body will (if called at all) be evaluated+with the demand that consumes the entire join-binding, in this case+the argument demand from g. Whizzo! g evaluates both components of+its argument pair, so p will certainly be evaluated if j is called.++For f to be strict in p, we need /all/ paths to evaluate p; in this+case the C branch does so too, so we are fine. So, as usual, we need+to transport demands on free variables to the call site(s). Compare+Note [Lazy and unleashable free variables].++The implementation is easy. When analysing a join point, we can+analyse its body with the demand from the entire join-binding (written+let_dmd here).++Another win for join points! Trac #13543.+ Note [Demand analysis for trivial right-hand sides] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Consider@@ -987,7 +1034,7 @@ error stub, but which has RULES, you may want it not to be eliminated in favour of error! -Note [Lazy and unleasheable free variables]+Note [Lazy and unleashable free variables] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We put the strict and once-used FVs in the DmdType of the Id, so that at its call sites we unleash demands on its strict fvs.
stranal/WorkWrap.hs view
@@ -7,6 +7,8 @@ {-# LANGUAGE CPP #-} module WorkWrap ( wwTopBinds ) where +import GhcPrelude+ import CoreSyn import CoreUnfold ( certainlyWillInline, mkWwInlineRule, mkWorkerUnfolding ) import CoreUtils ( exprType, exprIsHNF )@@ -180,7 +182,7 @@ where f is strict in y, we might get a more efficient loop by w/w'ing f. But that would make a new unfolding which would overwrite the old-one! So the function would no longer be ININABLE, and in particular+one! So the function would no longer be INLNABLE, and in particular will not be specialised at call sites in other modules. This comes in practice (Trac #6056).@@ -230,7 +232,7 @@ g x y p = case p of (I# p#) -> $wg x y p# -Now, in this case the reboxing will float into the True branch, an so+Now, in this case the reboxing will float into the True branch, and so the allocation will only happen on the error path. But it won't float inwards if there are multiple branches that call (f p), so the reboxing will happen on every call of g. Disaster.@@ -374,6 +376,10 @@ At one stage I tried making the wrapper inlining always-active, and that had a very bad effect on nofib/imaginary/x2n1; a wrapper was inlined before the specialisation fired.++The use an inl_inline of NoUserInline to distinguish this pragma from one+that was given by the user. In particular, CSE will not happen if there is a+user-specified pragma, but should happen for w/w’ed things (#14186). -} tryWW :: DynFlags@@ -521,7 +527,7 @@ wrap_act = ActiveAfter NoSourceText 0 wrap_rhs = wrap_fn work_id wrap_prag = InlinePragma { inl_src = SourceText "{-# INLINE"- , inl_inline = Inline+ , inl_inline = NoUserInline , inl_sat = Nothing , inl_act = wrap_act , inl_rule = rule_match_info }
stranal/WwLib.hs view
@@ -13,6 +13,8 @@ #include "HsVersions.h" +import GhcPrelude+ import CoreSyn import CoreUtils ( exprType, mkCast ) import Id@@ -587,8 +589,11 @@ ; let unpk_args = zipWith3 mk_ww_arg uniqs inst_con_arg_tys cs unbox_fn = mkUnpackCase (Var arg) co uniq1 data_con unpk_args- rebox_fn = Let (NonRec arg con_app)- con_app = mkConApp2 data_con inst_tys unpk_args `mkCast` mkSymCo co+ arg_no_unf = zapStableUnfolding arg+ -- See Note [Zap unfolding when beta-reducing]+ -- in Simplify.hs; and see Trac #13890+ rebox_fn = Let (NonRec arg_no_unf con_app)+ con_app = mkConApp2 data_con inst_tys unpk_args `mkCast` mkSymCo co ; (_, worker_args, wrap_fn, work_fn) <- mkWWstr dflags fam_envs unpk_args ; return (True, worker_args, unbox_fn . wrap_fn, work_fn . rebox_fn) } -- Don't pass the arg, rebox instead
typecheck/FamInst.hs view
@@ -7,13 +7,14 @@ checkFamInstConsistency, tcExtendLocalFamInstEnv, tcLookupDataFamInst, tcLookupDataFamInst_maybe, tcInstNewTyCon_maybe, tcTopNormaliseNewTypeTF_maybe,- checkRecFamInstConsistency, newFamInst, -- * Injectivity makeInjectivityErrors, injTyVarsOfType, injTyVarsOfTypes ) where +import GhcPrelude+ import HscTypes import FamInstEnv import InstEnv( roughMatchTcs )@@ -41,11 +42,6 @@ import VarSet import Bag( Bag, unionBags, unitBag ) import Control.Monad-import Unique-import NameEnv-import Data.Set (Set)-import qualified Data.Set as Set-import Data.List #include "HsVersions.h" @@ -103,8 +99,7 @@ every pair of instances we must check that they are consistent. - For family instances coming from `dep_finsts`, this is checked in-checkFamInstConsistency, called from tcRnImports, and in-checkRecFamInstConsistency, called from tcTyClGroup. See Note+checkFamInstConsistency, called from tcRnImports. See Note [Checking family instance consistency] for details on this check (and in particular how we avoid having to do all these checks for every module we compile).@@ -220,83 +215,71 @@ There is some fancy footwork regarding hs-boot module loops, see Note [Don't check hs-boot type family instances too early]--} --- The optimisation of overlap tests is based on determining pairs of modules--- whose family instances need to be checked for consistency.----data ModulePair = ModulePair Module Module- -- Invariant: first Module < second Module- -- use the smart constructor+Note [Checking family instance optimization]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+As explained in Note [Checking family instance consistency]+we need to ensure that every pair of transitive imports that define type family+instances is consistent. --- | Smart constructor that establishes the invariant-modulePair :: Module -> Module -> ModulePair-modulePair a b- | a < b = ModulePair a b- | otherwise = ModulePair b a+Let's define df(A) = transitive imports of A that define type family instances++ A, if A defines type family instances -instance Eq ModulePair where- (ModulePair a1 b1) == (ModulePair a2 b2) = a1 == a2 && b1 == b2+Then for every direct import A, df(A) is already consistent. -instance Ord ModulePair where- (ModulePair a1 b1) `compare` (ModulePair a2 b2) =- nonDetCmpModule a1 a2 `thenCmp`- nonDetCmpModule b1 b2- -- See Note [ModulePairSet determinism and performance]+Let's name the current module M. -instance Outputable ModulePair where- ppr (ModulePair m1 m2) = angleBrackets (ppr m1 <> comma <+> ppr m2)+We want to make sure that df(M) is consistent.+df(M) = df(D_1) U df(D_2) U ... U df(D_i) where D_1 .. D_i are direct imports. --- Fast, nondeterministic comparison on Module. Don't use when the ordering--- can change the ABI. See Note [ModulePairSet determinism and performance]-nonDetCmpModule :: Module -> Module -> Ordering-nonDetCmpModule a b =- nonDetCmpUnique (getUnique $ moduleUnitId a) (getUnique $ moduleUnitId b)- `thenCmp`- nonDetCmpUnique (getUnique $ moduleName a) (getUnique $ moduleName b)+We perform the check iteratively, maintaining a set of consistent modules 'C'+and trying to add df(D_i) to it. -type ModulePairSet = Set ModulePair-{--Note [ModulePairSet determinism and performance]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The size of ModulePairSet is quadratic in the number of modules.-The Ord instance for Module uses string comparison which is linear in the-length of ModuleNames and UnitIds. This adds up to a significant cost, see-#12191.+The key part is how to ensure that the union C U df(D_i) is consistent. -To get reasonable performance ModulePairSet uses nondeterministic ordering-on Module based on Uniques. It doesn't affect the ABI, because it only-determines the order the modules are checked for family instance consistency.-See Note [Unique Determinism] in Unique--}+Let's consider two modules: A and B from C U df(D_i).+There are nine possible ways to choose A and B from C U df(D_i): -listToSet :: [ModulePair] -> ModulePairSet-listToSet l = Set.fromList l+ | A in C only | A in C and B in df(D_i) | A in df(D_i) only+--------------------------------------------------------------------------------+B in C only | Already checked | Already checked | Needs to be checked+ | when checking C | when checking C |+--------------------------------------------------------------------------------+B in C and | Already checked | Already checked | Already checked when+B in df(D_i) | when checking C | when checking C | checking df(D_i)+--------------------------------------------------------------------------------+B in df(D_i) | Needs to be | Already checked | Already checked when+only | checked | when checking df(D_i) | checking df(D_i) --- | Check family instance consistency, given:------ 1. The list of all modules transitively imported by us--- which define a family instance (these are the ones--- we have to check for consistency), and------ 2. The list of modules which we directly imported--- (these specify the sets of family instance defining--- modules which are already known to be consistent).------ See Note [Checking family instance consistency] for more--- details, and Note [The type family instance consistency story]--- for the big picture.---+That means to ensure that C U df(D_i) is consistent we need to check every+module from C - df(D_i) against every module from df(D_i) - C and+every module from df(D_i) - C against every module from C - df(D_i).+But since the checks are symmetric it suffices to pick A from C - df(D_i)+and B from df(D_i) - C.++In other words these are the modules we need to check:+ [ (m1, m2) | m1 <- C, m1 not in df(D_i)+ , m2 <- df(D_i), m2 not in C ]++One final thing to note here is that if there's lot of overlap between+subsequent df(D_i)'s then we expect those set differences to be small.+That situation should be pretty common in practice, there's usually+a set of utility modules that every module imports directly or indirectly.++This is basically the idea from #13092, comment:14.+-}+ -- This function doesn't check ALL instances for consistency, -- only ones that aren't involved in recursive knot-tying -- loops; see Note [Don't check hs-boot type family instances too early].--- It returns a modified 'TcGblEnv' that has saved the--- instances that need to be checked later; use 'checkRecFamInstConsistency'--- to check those.-checkFamInstConsistency :: [Module] -> [Module] -> TcM TcGblEnv-checkFamInstConsistency famInstMods directlyImpMods+-- We don't need to check the current module, this is done in+-- tcExtendLocalFamInstEnv.+-- See Note [The type family instance consistency story].+checkFamInstConsistency :: [Module] -> TcM ()+checkFamInstConsistency directlyImpMods = do { dflags <- getDynFlags ; (eps, hpt) <- getEpsAndHpt+ ; traceTc "checkFamInstConsistency" (ppr directlyImpMods) ; let { -- Fetch the iface of a given module. Must succeed as -- all directly imported modules must already have been loaded. modIface mod =@@ -305,36 +288,81 @@ (ppr mod $$ pprHPT hpt) Just iface -> iface - -- Which modules were checked for consistency when we compiled- -- `mod`? Itself and its dep_finsts.- ; modConsistent mod = mod : (dep_finsts . mi_deps . modIface $ mod)+ -- Which family instance modules were checked for consistency+ -- when we compiled `mod`?+ -- Itself (if a family instance module) and its dep_finsts.+ -- This is df(D_i) from+ -- Note [Checking family instance optimization]+ ; modConsistent :: Module -> [Module]+ ; modConsistent mod =+ if mi_finsts (modIface mod) then mod:deps else deps+ where+ deps = dep_finsts . mi_deps . modIface $ mod ; hmiModule = mi_module . hm_iface ; hmiFamInstEnv = extendFamInstEnvList emptyFamInstEnv . md_fam_insts . hm_details ; hpt_fam_insts = mkModuleEnv [ (hmiModule hmi, hmiFamInstEnv hmi) | hmi <- eltsHpt hpt]- ; groups = map modConsistent directlyImpMods- ; okPairs = listToSet $ concatMap allPairs groups- -- instances of okPairs are consistent- ; criticalPairs = listToSet $ allPairs famInstMods- -- all pairs that we need to consider- ; toCheckPairs =- Set.elems $ criticalPairs `Set.difference` okPairs- -- the difference gives us the pairs we need to check now- -- See Note [ModulePairSet determinism and performance]+ } - ; pending_checks <- mapM (check hpt_fam_insts) toCheckPairs- ; tcg_env <- getGblEnv- ; return tcg_env { tcg_pending_fam_checks- = foldl' (plusNameEnv_C (++)) emptyNameEnv pending_checks }+ ; checkMany hpt_fam_insts modConsistent directlyImpMods } where- allPairs [] = []- allPairs (m:ms) = map (modulePair m) ms ++ allPairs ms-- check hpt_fam_insts (ModulePair m1 m2)+ -- See Note [Checking family instance optimization]+ checkMany+ :: ModuleEnv FamInstEnv -- home package family instances+ -> (Module -> [Module]) -- given A, modules checked when A was checked+ -> [Module] -- modules to process+ -> TcM ()+ checkMany hpt_fam_insts modConsistent mods = go [] emptyModuleSet mods+ where+ go :: [Module] -- list of consistent modules+ -> ModuleSet -- set of consistent modules, same elements as the+ -- list above+ -> [Module] -- modules to process+ -> TcM ()+ go _ _ [] = return ()+ go consistent consistent_set (mod:mods) = do+ sequence_+ [ check hpt_fam_insts m1 m2+ | m1 <- to_check_from_mod+ -- loop over toCheckFromMod first, it's usually smaller,+ -- it may even be empty+ , m2 <- to_check_from_consistent+ ]+ go consistent' consistent_set' mods+ where+ mod_deps_consistent = modConsistent mod+ mod_deps_consistent_set = mkModuleSet mod_deps_consistent+ consistent' = to_check_from_mod ++ consistent+ consistent_set' =+ extendModuleSetList consistent_set to_check_from_mod+ to_check_from_consistent =+ filterOut (`elemModuleSet` mod_deps_consistent_set) consistent+ to_check_from_mod =+ filterOut (`elemModuleSet` consistent_set) mod_deps_consistent+ -- Why don't we just minusModuleSet here?+ -- We could, but doing so means one of two things:+ --+ -- 1. When looping over the cartesian product we convert+ -- a set into a non-deterministicly ordered list. Which+ -- happens to be fine for interface file determinism+ -- in this case, today, because the order only+ -- determines the order of deferred checks. But such+ -- invariants are hard to keep.+ --+ -- 2. When looping over the cartesian product we convert+ -- a set into a deterministically ordered list - this+ -- adds some additional cost of sorting for every+ -- direct import.+ --+ -- That also explains why we need to keep both 'consistent'+ -- and 'consistentSet'.+ --+ -- See also Note [ModuleEnv performance and determinism].+ check hpt_fam_insts m1 m2 = do { env1' <- getFamInsts hpt_fam_insts m1 ; env2' <- getFamInsts hpt_fam_insts m2 -- We're checking each element of env1 against env2.@@ -392,12 +420,9 @@ -- import B -- data T = MkT --- -- However, this is not yet done; see #13981.- --- -- Note that it is NOT necessary to defer for occurrences in the- -- RHS (e.g., type instance F Int = T, in the above example),- -- since that never participates in consistency checking- -- in any nontrivial way.+ -- In fact, it is even necessary to defer for occurrences in+ -- the RHS, because we may test for *compatibility* in event+ -- of an overlap. -- -- Why don't we defer ALL of the checks to later? Well, many -- instances aren't involved in the recursive loop at all. So@@ -411,40 +436,11 @@ -- -- See also Note [Tying the knot] and Note [Type-checking inside the knot] -- for why we are doing this at all.- ; this_mod <- getModule- -- NB: == this_mod only holds if there's an hs-boot file;- -- otherwise we cannot possible see instances for families- -- defined by the module we are compiling in imports.- ; let shouldCheckNow = ((/= this_mod) . nameModule . fi_fam)- (check_now, check_later) =- partition shouldCheckNow (famInstEnvElts env1)+ ; let check_now = famInstEnvElts env1 ; mapM_ (checkForConflicts (emptyFamInstEnv, env2)) check_now ; mapM_ (checkForInjectivityConflicts (emptyFamInstEnv,env2)) check_now- ; let check_later_map =- extendNameEnvList_C (++) emptyNameEnv- [(fi_fam finst, [finst]) | finst <- check_later]- ; return (mapNameEnv (\xs -> [(xs, env2)]) check_later_map) } --- | Given a 'TyCon' that has been incorporated into the type--- environment (the knot is tied), if it is a type family, check--- that all deferred instances for it are consistent.--- See Note [Don't check hs-boot type family instances too early]-checkRecFamInstConsistency :: TyCon -> TcM ()-checkRecFamInstConsistency tc = do- tcg_env <- getGblEnv- let checkConsistency tc- | isFamilyTyCon tc- , Just pairs <- lookupNameEnv (tcg_pending_fam_checks tcg_env)- (tyConName tc)- = forM_ pairs $ \(check_now, env2) -> do- mapM_ (checkForConflicts (emptyFamInstEnv, env2)) check_now- mapM_ (checkForInjectivityConflicts (emptyFamInstEnv,env2)) check_now- | otherwise- = return ()- checkConsistency tc-- getFamInsts :: ModuleEnv FamInstEnv -> Module -> TcM FamInstEnv getFamInsts hpt_fam_insts mod | Just env <- lookupModuleEnv hpt_fam_insts mod = return env@@ -680,7 +676,7 @@ checkForInjectivityConflicts instEnvs famInst | isTypeFamilyTyCon tycon -- type family is injective in at least one argument- , Injective inj <- familyTyConInjectivityInfo tycon = do+ , Injective inj <- tyConInjectivityInfo tycon = do { let axiom = coAxiomSingleBranch fi_ax conflicts = lookupFamInstEnvInjectivityConflicts inj instEnvs famInst -- see Note [Verifying injectivity annotation] in FamInstEnv@@ -768,7 +764,7 @@ = unitVarSet v `unionVarSet` injTyVarsOfType (tyVarKind v) injTyVarsOfType (TyConApp tc tys) | isTypeFamilyTyCon tc- = case familyTyConInjectivityInfo tc of+ = case tyConInjectivityInfo tc of NotInjective -> emptyVarSet Injective inj -> injTyVarsOfTypes (filterByList inj tys) | otherwise@@ -796,7 +792,7 @@ = isTFHeaded ty' isTFHeaded ty | (TyConApp tc args) <- ty , isTypeFamilyTyCon tc- = tyConArity tc == length args+ = args `lengthIs` tyConArity tc isTFHeaded _ = False
typecheck/FunDeps.hs view
@@ -19,6 +19,8 @@ #include "HsVersions.h" +import GhcPrelude+ import Name import Var import Class@@ -237,7 +239,7 @@ -- for fundep (x,y -> p,q) from class (C x p y q) -- If (sx,sy) unifies with (tx,ty), take the subst S --- 'qtvs' are the quantified type variables, the ones which an be instantiated+-- 'qtvs' are the quantified type variables, the ones which can be instantiated -- to make the types match. For example, given -- class C a b | a->b where ... -- instance C (Maybe x) (Tree x) where ..@@ -255,8 +257,8 @@ = [] -- Filter out ones that can't possibly match, | otherwise- = ASSERT2( length tys_inst == length tys_actual &&- length tys_inst == length clas_tvs+ = ASSERT2( equalLength tys_inst tys_actual &&+ equalLength tys_inst clas_tvs , ppr tys_inst <+> ppr tys_actual ) case tcMatchTyKis ltys1 ltys2 of@@ -643,7 +645,7 @@ | otherwise = Skolem eq_inst i1 i2 = instanceDFunId i1 == instanceDFunId i2- -- An single instance may appear twice in the un-nubbed conflict list+ -- A single instance may appear twice in the un-nubbed conflict list -- because it may conflict with more than one fundep. E.g. -- class C a b c | a -> b, a -> c -- instance C Int Bool Bool
typecheck/Inst.hs view
@@ -7,6 +7,7 @@ -} {-# LANGUAGE CPP, MultiWayIf, TupleSections #-}+{-# LANGUAGE FlexibleContexts #-} module Inst ( deeplySkolemise,@@ -14,7 +15,7 @@ instCall, instDFunType, instStupidTheta, instTyVarsWith, newWanted, newWanteds, - tcInstBinders, tcInstBindersX, tcInstBinderX,+ tcInstBinders, tcInstBinder, newOverloadedLit, mkOverLit, @@ -31,10 +32,12 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} TcExpr( tcPolyExpr, tcSyntaxOp )-import {-# SOURCE #-} TcUnify( unifyType, unifyKind, noThing )+import {-# SOURCE #-} TcUnify( unifyType, unifyKind ) -import BasicTypes ( SourceText(..) )+import BasicTypes ( IntegralLit(..), SourceText(..) ) import FastString import HsSyn import TcHsSyn@@ -47,7 +50,7 @@ import FunDeps import TcMType import Type-import TyCoRep ( TyBinder(..) )+import TyCoRep import TcType import HscTypes import Class( Class )@@ -75,7 +78,7 @@ ************************************************************************ -} -newMethodFromName :: CtOrigin -> Name -> TcRhoType -> TcM (HsExpr TcId)+newMethodFromName :: CtOrigin -> Name -> TcRhoType -> TcM (HsExpr GhcTcId) -- Used when Name is the wired-in name for a wired-in class method, -- so the caller knows its type for sure, which should be of form -- forall a. C a => <blah>@@ -195,15 +198,16 @@ ; let inst_theta' = substTheta subst inst_theta sigma' = substTy subst (mkForAllTys leave_bndrs $ mkFunTys leave_theta rho)+ inst_tv_tys' = mkTyVarTys inst_tvs' - ; wrap1 <- instCall orig (mkTyVarTys inst_tvs') inst_theta'+ ; wrap1 <- instCall orig inst_tv_tys' inst_theta' ; traceTc "Instantiating" (vcat [ text "all tyvars?" <+> ppr inst_all , text "origin" <+> pprCtOrigin orig- , text "type" <+> ppr ty+ , text "type" <+> debugPprType ty , text "theta" <+> ppr theta , text "leave_bndrs" <+> ppr leave_bndrs- , text "with" <+> ppr inst_tvs'+ , text "with" <+> vcat (map debugPprType inst_tv_tys') , text "theta:" <+> ppr inst_theta' ]) ; (wrap2, rho2) <-@@ -253,8 +257,9 @@ deeply_instantiate orig subst ty | Just (arg_tys, tvs, theta, rho) <- tcDeepSplitSigmaTy_maybe ty = do { (subst', tvs') <- newMetaTyVarsX subst tvs- ; ids1 <- newSysLocalIds (fsLit "di") (substTys subst' arg_tys)- ; let theta' = substTheta subst' theta+ ; let arg_tys' = substTys subst' arg_tys+ theta' = substTheta subst' theta+ ; ids1 <- newSysLocalIds (fsLit "di") arg_tys' ; wrap1 <- instCall orig (mkTyVarTys tvs') theta' ; traceTc "Instantiating (deeply)" (vcat [ text "origin" <+> pprCtOrigin orig , text "type" <+> ppr ty@@ -267,7 +272,7 @@ <.> wrap2 <.> wrap1 <.> mkWpEvVarApps ids1,- mkFunTys arg_tys rho2) }+ mkFunTys arg_tys' rho2) } | otherwise = do { let ty' = substTy subst ty@@ -349,13 +354,13 @@ where go pred | Just (Nominal, ty1, ty2) <- getEqPredTys_maybe pred -- Try short-cut #1- = do { co <- unifyType noThing ty1 ty2+ = do { co <- unifyType Nothing ty1 ty2 ; return (EvCoercion co) } -- Try short-cut #2 | Just (tc, args@[_, _, ty1, ty2]) <- splitTyConApp_maybe pred , tc `hasKey` heqTyConKey- = do { co <- unifyType noThing ty1 ty2+ = do { co <- unifyType Nothing ty1 ty2 ; return (EvDFunApp (dataConWrapId heqDataCon) args [EvCoercion co]) } | otherwise@@ -403,26 +408,21 @@ --------------------------- -- | This is used to instantiate binders when type-checking *types* only.--- See also Note [Bidirectional type checking]-tcInstBinders :: [TyBinder] -> TcM (TCvSubst, [TcType])-tcInstBinders = tcInstBindersX emptyTCvSubst Nothing---- | This is used to instantiate binders when type-checking *types* only. -- The @VarEnv Kind@ gives some known instantiations. -- See also Note [Bidirectional type checking]-tcInstBindersX :: TCvSubst -> Maybe (VarEnv Kind)+tcInstBinders :: TCvSubst -> Maybe (VarEnv Kind) -> [TyBinder] -> TcM (TCvSubst, [TcType])-tcInstBindersX subst mb_kind_info bndrs- = do { (subst, args) <- mapAccumLM (tcInstBinderX mb_kind_info) subst bndrs+tcInstBinders subst mb_kind_info bndrs+ = do { (subst, args) <- mapAccumLM (tcInstBinder mb_kind_info) subst bndrs ; traceTc "instantiating tybinders:" (vcat $ zipWith (\bndr arg -> ppr bndr <+> text ":=" <+> ppr arg) bndrs args) ; return (subst, args) } -- | Used only in *types*-tcInstBinderX :: Maybe (VarEnv Kind)+tcInstBinder :: Maybe (VarEnv Kind) -> TCvSubst -> TyBinder -> TcM (TCvSubst, TcType)-tcInstBinderX mb_kind_info subst (Named (TvBndr tv _))+tcInstBinder mb_kind_info subst (Named (TvBndr tv _)) = case lookup_tv tv of Just ki -> return (extendTvSubstAndInScope subst tv ki, ki) Nothing -> do { (subst', tv') <- newMetaTyVarX subst tv@@ -432,16 +432,17 @@ ; lookupVarEnv env tv } -tcInstBinderX _ subst (Anon ty)+tcInstBinder _ subst (Anon ty) -- This is the *only* constraint currently handled in types. | Just (mk, role, k1, k2) <- get_pred_tys_maybe substed_ty = do { let origin = TypeEqOrigin { uo_actual = k1 , uo_expected = k2- , uo_thing = Nothing }+ , uo_thing = Nothing+ , uo_visible = True } ; co <- case role of- Nominal -> unifyKind noThing k1 k2+ Nominal -> unifyKind Nothing k1 k2 Representational -> emitWantedEq origin KindLevel role k1 k2- Phantom -> pprPanic "tcInstBinderX Phantom" (ppr ty)+ Phantom -> pprPanic "tcInstBinder Phantom" (ppr ty) ; arg' <- mk co k1 k2 ; return (subst, arg') } @@ -526,9 +527,9 @@ -} -newOverloadedLit :: HsOverLit Name+newOverloadedLit :: HsOverLit GhcRn -> ExpRhoType- -> TcM (HsOverLit TcId)+ -> TcM (HsOverLit GhcTcId) newOverloadedLit lit@(OverLit { ol_val = val, ol_rebindable = rebindable }) res_ty | not rebindable@@ -554,9 +555,9 @@ -- Does not handle things that 'shortCutLit' can handle. See also -- newOverloadedLit in TcUnify newNonTrivialOverloadedLit :: CtOrigin- -> HsOverLit Name+ -> HsOverLit GhcRn -> ExpRhoType- -> TcM (HsOverLit TcId)+ -> TcM (HsOverLit GhcTcId) newNonTrivialOverloadedLit orig lit@(OverLit { ol_val = val, ol_witness = HsVar (L _ meth_name) , ol_rebindable = rebindable }) res_ty@@ -574,16 +575,17 @@ = pprPanic "newNonTrivialOverloadedLit" (ppr lit) -------------mkOverLit :: OverLitVal -> TcM HsLit-mkOverLit (HsIntegral src i)+mkOverLit ::(HasDefaultX p, SourceTextX p) => OverLitVal -> TcM (HsLit p)+mkOverLit (HsIntegral i) = do { integer_ty <- tcMetaTy integerTyConName- ; return (HsInteger src i integer_ty) }+ ; return (HsInteger (setSourceText $ il_text i)+ (il_value i) integer_ty) } mkOverLit (HsFractional r) = do { rat_ty <- tcMetaTy rationalTyConName- ; return (HsRat r rat_ty) }+ ; return (HsRat def r rat_ty) } -mkOverLit (HsIsString src s) = return (HsString src s)+mkOverLit (HsIsString src s) = return (HsString (setSourceText src) s) {- ************************************************************************@@ -618,9 +620,10 @@ -} tcSyntaxName :: CtOrigin- -> TcType -- Type to instantiate it at- -> (Name, HsExpr Name) -- (Standard name, user name)- -> TcM (Name, HsExpr TcId) -- (Standard name, suitable expression)+ -> TcType -- ^ Type to instantiate it at+ -> (Name, HsExpr GhcRn) -- ^ (Standard name, user name)+ -> TcM (Name, HsExpr GhcTcId)+ -- ^ (Standard name, suitable expression) -- USED ONLY FOR CmdTop (sigh) *** -- See Note [CmdSyntaxTable] in HsExpr @@ -647,7 +650,7 @@ expr <- tcPolyExpr (L span user_nm_expr) sigma1 return (std_nm, unLoc expr) -syntaxNameCtxt :: HsExpr Name -> CtOrigin -> Type -> TidyEnv+syntaxNameCtxt :: HsExpr GhcRn -> CtOrigin -> Type -> TidyEnv -> TcRn (TidyEnv, SDoc) syntaxNameCtxt name orig ty tidy_env = do { inst_loc <- getCtLocM orig (Just TypeLevel)@@ -704,9 +707,9 @@ ; oflag <- getOverlapFlag overlap_mode ; let inst = mkLocalInstance dfun oflag tvs' clas tys'- ; warnIf (Reason Opt_WarnOrphans)- (isOrphan (is_orphan inst))- (instOrphWarn inst)+ ; warnIfFlag Opt_WarnOrphans+ (isOrphan (is_orphan inst))+ (instOrphWarn inst) ; return inst } instOrphWarn :: ClsInst -> SDoc
typecheck/TcAnnotations.hs view
@@ -10,14 +10,16 @@ module TcAnnotations ( tcAnnotations, annCtxt ) where +import GhcPrelude+ import {-# SOURCE #-} TcSplice ( runAnnotation ) import Module import DynFlags import Control.Monad ( when ) import HsSyn-import Annotations import Name+import Annotations import TcRnMonad import SrcLoc import Outputable@@ -26,13 +28,13 @@ -- compilation on those platforms shouldn't fail just due to -- annotations #ifndef GHCI-tcAnnotations :: [LAnnDecl Name] -> TcM [Annotation]+tcAnnotations :: [LAnnDecl GhcRn] -> TcM [Annotation] tcAnnotations anns = do dflags <- getDynFlags case gopt Opt_ExternalInterpreter dflags of True -> tcAnnotations' anns False -> warnAnns anns-warnAnns :: [LAnnDecl Name] -> TcM [Annotation]+warnAnns :: [LAnnDecl GhcRn] -> TcM [Annotation] --- No GHCI; emit a warning (not an error) and ignore. cf Trac #4268 warnAnns [] = return [] warnAnns anns@(L loc _ : _)@@ -41,14 +43,14 @@ <+> text "because this is a stage-1 compiler without -fexternal-interpreter or doesn't support GHCi") ; return [] } #else-tcAnnotations :: [LAnnDecl Name] -> TcM [Annotation]+tcAnnotations :: [LAnnDecl GhcRn] -> TcM [Annotation] tcAnnotations = tcAnnotations' #endif -tcAnnotations' :: [LAnnDecl Name] -> TcM [Annotation]+tcAnnotations' :: [LAnnDecl GhcRn] -> TcM [Annotation] tcAnnotations' anns = mapM tcAnnotation anns -tcAnnotation :: LAnnDecl Name -> TcM Annotation+tcAnnotation :: LAnnDecl GhcRn -> TcM Annotation tcAnnotation (L loc ann@(HsAnnotation _ provenance expr)) = do -- Work out what the full target of this annotation was mod <- getModule@@ -64,11 +66,12 @@ safeHsErr = vcat [ text "Annotations are not compatible with Safe Haskell." , text "See https://ghc.haskell.org/trac/ghc/ticket/10826" ] -annProvenanceToTarget :: Module -> AnnProvenance Name -> AnnTarget Name+annProvenanceToTarget :: Module -> AnnProvenance Name+ -> AnnTarget Name annProvenanceToTarget _ (ValueAnnProvenance (L _ name)) = NamedTarget name annProvenanceToTarget _ (TypeAnnProvenance (L _ name)) = NamedTarget name annProvenanceToTarget mod ModuleAnnProvenance = ModuleTarget mod -annCtxt :: (OutputableBndrId id) => AnnDecl id -> SDoc+annCtxt :: (SourceTextX p, OutputableBndrId p) => AnnDecl p -> SDoc annCtxt ann = hang (text "In the annotation:") 2 (ppr ann)
typecheck/TcArrows.hs view
@@ -6,9 +6,12 @@ -} {-# LANGUAGE RankNTypes, TupleSections #-}+{-# LANGUAGE TypeFamilies #-} module TcArrows ( tcProc ) where +import GhcPrelude+ import {-# SOURCE #-} TcExpr( tcMonoExpr, tcInferRho, tcSyntaxOp, tcCheckId, tcPolyExpr ) import HsSyn@@ -76,9 +79,9 @@ ************************************************************************ -} -tcProc :: InPat Name -> LHsCmdTop Name -- proc pat -> expr+tcProc :: InPat GhcRn -> LHsCmdTop GhcRn -- proc pat -> expr -> ExpRhoType -- Expected type of whole proc expression- -> TcM (OutPat TcId, LHsCmdTop TcId, TcCoercion)+ -> TcM (OutPat GhcTcId, LHsCmdTop GhcTcId, TcCoercion) tcProc pat cmd exp_ty = newArrowScope $@@ -114,9 +117,9 @@ --------------------------------------- tcCmdTop :: CmdEnv- -> LHsCmdTop Name+ -> LHsCmdTop GhcRn -> CmdType- -> TcM (LHsCmdTop TcId)+ -> TcM (LHsCmdTop GhcTcId) tcCmdTop env (L loc (HsCmdTop cmd _ _ names)) cmd_ty@(cmd_stk, res_ty) = setSrcSpan loc $@@ -124,14 +127,14 @@ ; names' <- mapM (tcSyntaxName ProcOrigin (cmd_arr env)) names ; return (L loc $ HsCmdTop cmd' cmd_stk res_ty names') } -----------------------------------------tcCmd :: CmdEnv -> LHsCmd Name -> CmdType -> TcM (LHsCmd TcId)+tcCmd :: CmdEnv -> LHsCmd GhcRn -> CmdType -> TcM (LHsCmd GhcTcId) -- The main recursive function tcCmd env (L loc cmd) res_ty = setSrcSpan loc $ do { cmd' <- tc_cmd env cmd res_ty ; return (L loc cmd') } -tc_cmd :: CmdEnv -> HsCmd Name -> CmdType -> TcM (HsCmd TcId)+tc_cmd :: CmdEnv -> HsCmd GhcRn -> CmdType -> TcM (HsCmd GhcTcId) tc_cmd env (HsCmdPar cmd) res_ty = do { cmd' <- tcCmd env cmd res_ty ; return (HsCmdPar cmd') }@@ -238,7 +241,7 @@ tc_cmd env (HsCmdLam (MG { mg_alts = L l [L mtch_loc- (match@(Match _ pats _maybe_rhs_sig grhss))],+ (match@(Match { m_pats = pats, m_grhss = grhss }))], mg_origin = origin })) (cmd_stk, res_ty) = addErrCtxt (pprMatchInCtxt match) $@@ -249,7 +252,8 @@ tcPats LambdaExpr pats (map mkCheckExpType arg_tys) $ tc_grhss grhss cmd_stk' (mkCheckExpType res_ty) - ; let match' = L mtch_loc (Match LambdaExpr pats' Nothing grhss')+ ; let match' = L mtch_loc (Match { m_ctxt = LambdaExpr, m_pats = pats'+ , m_grhss = grhss' }) arg_tys = map hsLPatType pats' cmd' = HsCmdLam (MG { mg_alts = L l [match'], mg_arg_tys = arg_tys , mg_res_ty = res_ty, mg_origin = origin })@@ -274,7 +278,7 @@ -- Do notation tc_cmd env (HsCmdDo (L l stmts) _) (cmd_stk, res_ty)- = do { co <- unifyType noThing unitTy cmd_stk -- Expecting empty argument stack+ = do { co <- unifyType Nothing unitTy cmd_stk -- Expecting empty argument stack ; stmts' <- tcStmts ArrowExpr (tcArrDoStmt env) stmts res_ty ; return (mkHsCmdWrap (mkWpCastN co) (HsCmdDo (L l stmts') res_ty)) } @@ -304,7 +308,7 @@ ; return (HsCmdArrForm expr' f fixity cmd_args') } where- tc_cmd_arg :: LHsCmdTop Name -> TcM (LHsCmdTop TcId, TcType)+ tc_cmd_arg :: LHsCmdTop GhcRn -> TcM (LHsCmdTop GhcTcId, TcType) tc_cmd_arg cmd = do { arr_ty <- newFlexiTyVarTy arrowTyConKind ; stk_ty <- newFlexiTyVarTy liftedTypeKind@@ -396,7 +400,7 @@ tcArrDoStmt _ _ stmt _ _ = pprPanic "tcArrDoStmt: unexpected Stmt" (ppr stmt) -tc_arr_rhs :: CmdEnv -> LHsCmd Name -> TcM (LHsCmd TcId, TcType)+tc_arr_rhs :: CmdEnv -> LHsCmd GhcRn -> TcM (LHsCmd GhcTcId, TcType) tc_arr_rhs env rhs = do { ty <- newFlexiTyVarTy liftedTypeKind ; rhs' <- tcCmd env rhs (unitTy, ty) ; return (rhs', ty) }@@ -423,5 +427,5 @@ ************************************************************************ -} -cmdCtxt :: HsCmd Name -> SDoc+cmdCtxt :: HsCmd GhcRn -> SDoc cmdCtxt cmd = text "In the command:" <+> ppr cmd
typecheck/TcBackpack.hs view
@@ -3,6 +3,7 @@ {-# LANGUAGE NondecreasingIndentation #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-} module TcBackpack ( findExtraSigImports', findExtraSigImports,@@ -16,6 +17,8 @@ instantiateSignature, ) where +import GhcPrelude+ import BasicTypes (defaultFixity) import Packages import TcRnExports@@ -45,7 +48,7 @@ import Outputable import Type import FastString-import RnEnv+import RnFixity ( lookupFixityRn ) import Maybes import TcEnv import Var@@ -157,7 +160,7 @@ -- TODO: Actually this error swizzle doesn't work let p (L _ ie) = name `elem` ieNames ie loc = case tcg_rn_exports tcg_env of- Just es | Just e <- find p es+ Just es | Just e <- find p (map fst es) -- TODO: maybe we can be a little more -- precise here and use the Located -- info for the *specific* name we matched.@@ -495,7 +498,33 @@ -- Note [Blank hsigs for all requirements] hsc_env <- getTopEnv dflags <- getDynFlags++ -- Copy over some things from the original TcGblEnv that+ -- we want to preserve+ updGblEnv (\env -> env {+ -- Renamed imports/declarations are often used+ -- by programs that use the GHC API, e.g., Haddock.+ -- These won't get filled by the merging process (since+ -- we don't actually rename the parsed module again) so+ -- we need to take them directly from the previous+ -- typechecking.+ --+ -- NB: the export declarations aren't in their final+ -- form yet. We'll fill those in when we reprocess+ -- the export declarations.+ tcg_rn_imports = tcg_rn_imports orig_tcg_env,+ tcg_rn_decls = tcg_rn_decls orig_tcg_env,+ -- Annotations+ tcg_ann_env = tcg_ann_env orig_tcg_env,+ -- Documentation header+ tcg_doc_hdr = tcg_doc_hdr orig_tcg_env+ -- tcg_dus?+ -- tcg_th_used = tcg_th_used orig_tcg_env,+ -- tcg_th_splice_used = tcg_th_splice_used orig_tcg_env+ -- tcg_th_top_level_locs = tcg_th_top_level_locs orig_tcg_env+ }) $ do tcg_env <- getGblEnv+ let outer_mod = tcg_mod tcg_env inner_mod = tcg_semantic_mod tcg_env mod_name = moduleName (tcg_mod tcg_env)@@ -529,37 +558,99 @@ -- gen_subst (nsubst,oks,ifaces) (imod@(IndefModule iuid _), ireq_iface) = do let insts = indefUnitIdInsts iuid+ isFromSignaturePackage =+ let inst_uid = fst (splitUnitIdInsts (IndefiniteUnitId iuid))+ pkg = getInstalledPackageDetails dflags inst_uid+ in null (exposedModules pkg)+ -- 3(a). Rename the exports according to how the dependency+ -- was instantiated. The resulting export list will be accurate+ -- except for exports *from the signature itself* (which may+ -- be subsequently updated by exports from other signatures in+ -- the merge. as1 <- tcRnModExports insts ireq_iface- let inst_uid = fst (splitUnitIdInsts (IndefiniteUnitId iuid))- pkg = getInstalledPackageDetails dflags inst_uid- -- Setup the import spec correctly, so that when we apply- -- IEModuleContents we pick up EVERYTHING- ispec = ImpSpec- ImpDeclSpec{- is_mod = mod_name,- is_as = mod_name,- is_qual = False,- is_dloc = loc- } ImpAll- rdr_env = mkGlobalRdrEnv (gresFromAvails (Just ispec) as1)+ -- 3(b). Thin the interface if it comes from a signature package. (thinned_iface, as2) <- case mb_exports of Just (L loc _)- | null (exposedModules pkg) -> setSrcSpan loc $ do- -- Suppress missing errors; we'll pick em up- -- when we test exports on the final thing- (msgs, mb_r) <- tryTc $+ -- Check if the package containing this signature is+ -- a signature package (i.e., does not expose any+ -- modules.) If so, we can thin it.+ | isFromSignaturePackage+ -> setSrcSpan loc $ do+ -- Suppress missing errors; they might be used to refer+ -- to entities from other signatures we are merging in.+ -- If an identifier truly doesn't exist in any of the+ -- signatures that are merged in, we will discover this+ -- when we run exports_from_avail on the final merged+ -- export list.+ (msgs, mb_r) <- tryTc $ do+ -- Suppose that we have written in a signature:+ -- signature A ( module A ) where {- empty -}+ -- If I am also inheriting a signature from a+ -- signature package, does 'module A' scope over+ -- all of its exports?+ --+ -- There are two possible interpretations:+ --+ -- 1. For non self-reexports, a module reexport+ -- is interpreted only in terms of the local+ -- signature module, and not any of the inherited+ -- ones. The reason for this is because after+ -- typechecking, module exports are completely+ -- erased from the interface of a file, so we+ -- have no way of "interpreting" a module reexport.+ -- Thus, it's only useful for the local signature+ -- module (where we have a useful GlobalRdrEnv.)+ --+ -- 2. On the other hand, a common idiom when+ -- you want to "export everything, plus a reexport"+ -- in modules is to say module A ( module A, reex ).+ -- This applies to signature modules too; and in+ -- particular, you probably still want the entities+ -- from the inherited signatures to be preserved+ -- too.+ --+ -- We think it's worth making a special case for+ -- self reexports to make use case (2) work. To+ -- do this, we take the exports of the inherited+ -- signature @as1@, and bundle them into a+ -- GlobalRdrEnv where we treat them as having come+ -- from the import @import A@. Thus, we will+ -- pick them up if they are referenced explicitly+ -- (@foo@) or even if we do a module reexport+ -- (@module A@).+ let ispec = ImpSpec ImpDeclSpec{+ -- NB: This needs to be mod name+ -- of the local signature, not+ -- the (original) module name of+ -- the inherited signature,+ -- because we need module+ -- LocalSig (from the local+ -- export list) to match it!+ is_mod = mod_name,+ is_as = mod_name,+ is_qual = False,+ is_dloc = loc+ } ImpAll+ rdr_env = mkGlobalRdrEnv (gresFromAvails (Just ispec) as1) setGblEnv tcg_env { tcg_rdr_env = rdr_env } $ exports_from_avail mb_exports rdr_env- (tcg_imports tcg_env) (tcg_semantic_mod tcg_env)+ -- NB: tcg_imports is also empty!+ emptyImportAvails+ (tcg_semantic_mod tcg_env) case mb_r of Just (_, as2) -> return (thinModIface as2 ireq_iface, as2) Nothing -> addMessages msgs >> failM+ -- We can't think signatures from non signature packages _ -> return (ireq_iface, as1)- let oks' | null (exposedModules pkg)+ -- 3(c). Only identifiers from signature packages are "ok" to+ -- import (that is, they are safe from a PVP perspective.)+ -- (NB: This code is actually dead right now.)+ let oks' | isFromSignaturePackage = extendOccSetList oks (exportOccs as2) | otherwise = oks+ -- 3(d). Extend the name substitution (performing shaping) mb_r <- extend_ns nsubst as2 case mb_r of Left err -> failWithTc err@@ -608,6 +699,7 @@ (mb_lies, _) <- exports_from_avail mb_exports rdr_env (tcg_imports tcg_env) (tcg_semantic_mod tcg_env) + {- -- NB: This is commented out, because warns above is disabled. -- If you tried to explicitly export an identifier that has a warning -- attached to it, that's probably a mistake. Warn about it. case mb_lies of@@ -620,8 +712,13 @@ text "Exported identifier" <+> quotes (ppr n) <+> text "will cause warnings if used.", parens (text "To suppress this warning, remove" <+> quotes (ppr n) <+> text "from the export list of this signature.") ]+ -} failIfErrsM++ -- Save the exports+ setGblEnv tcg_env { tcg_rn_exports = mb_lies } $ do+ tcg_env <- getGblEnv -- STEP 4: Rename the interfaces ext_ifaces <- forM thinned_ifaces $ \((IndefModule iuid _), ireq_iface) ->
typecheck/TcBinds.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE CPP, RankNTypes, ScopedTypeVariables #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-} module TcBinds ( tcLocalBinds, tcTopBinds, tcRecSelBinds, tcHsBootSigs, tcPolyCheck,@@ -14,6 +15,8 @@ chooseInferredQuantifiers, badBootDeclErr ) where +import GhcPrelude+ import {-# SOURCE #-} TcMatches ( tcGRHSsPat, tcMatchesFun ) import {-# SOURCE #-} TcExpr ( tcMonoExpr ) import {-# SOURCE #-} TcPatSyn ( tcInferPatSynDecl, tcCheckPatSynDecl@@ -37,7 +40,7 @@ import FamInst( tcGetFamInstEnvs ) import TyCon import TcType-import Type( mkStrLitTy, tidyOpenType, mkTyVarBinder, splitTyConApp_maybe)+import Type( mkStrLitTy, tidyOpenType, splitTyConApp_maybe) import TysPrim import TysWiredIn( mkBoxedTupleTy ) import Id@@ -66,6 +69,7 @@ import ConLike import Control.Monad+import Data.List.NonEmpty ( NonEmpty(..) ) #include "HsVersions.h" @@ -75,7 +79,7 @@ * * ********************************************************************* -} -addTypecheckedBinds :: TcGblEnv -> [LHsBinds Id] -> TcGblEnv+addTypecheckedBinds :: TcGblEnv -> [LHsBinds GhcTc] -> TcGblEnv addTypecheckedBinds tcg_env binds | isHsBootOrSig (tcg_src tcg_env) = tcg_env -- Do not add the code for record-selector bindings@@ -176,7 +180,8 @@ fm -} -tcTopBinds :: [(RecFlag, LHsBinds Name)] -> [LSig Name] -> TcM (TcGblEnv, TcLclEnv)+tcTopBinds :: [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn]+ -> TcM (TcGblEnv, TcLclEnv) -- The TcGblEnv contains the new tcg_binds and tcg_spects -- The TcLclEnv has an extended type envt for the new bindings tcTopBinds binds sigs@@ -227,10 +232,10 @@ -- `Nothing` in the case that the type is fixed by a type signature data CompleteSigType = AcceptAny | Fixed (Maybe ConLike) TyCon -tcCompleteSigs :: [LSig Name] -> TcM [CompleteMatch]+tcCompleteSigs :: [LSig GhcRn] -> TcM [CompleteMatch] tcCompleteSigs sigs = let- doOne :: Sig Name -> TcM (Maybe CompleteMatch)+ doOne :: Sig GhcRn -> TcM (Maybe CompleteMatch) doOne c@(CompleteMatchSig _ lns mtc) = fmap Just $ do addErrCtxt (text "In" <+> ppr c) $@@ -302,7 +307,7 @@ <+> quotes (ppr tc')) in mapMaybeM (addLocM doOne) sigs -tcRecSelBinds :: HsValBinds Name -> TcM TcGblEnv+tcRecSelBinds :: HsValBinds GhcRn -> TcM TcGblEnv tcRecSelBinds (ValBindsOut binds sigs) = tcExtendGlobalValEnv [sel_id | L _ (IdSig sel_id) <- sigs] $ do { (rec_sel_binds, tcg_env) <- discardWarnings $@@ -311,7 +316,7 @@ ; return tcg_env' } tcRecSelBinds (ValBindsIn {}) = panic "tcRecSelBinds" -tcHsBootSigs :: [(RecFlag, LHsBinds Name)] -> [LSig Name] -> TcM [Id]+tcHsBootSigs :: [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM [Id] -- A hs-boot file has only one BindGroup, and it only has type -- signatures in it. The renamer checked all this tcHsBootSigs binds sigs@@ -330,8 +335,8 @@ badBootDeclErr = text "Illegal declarations in an hs-boot file" -------------------------tcLocalBinds :: HsLocalBinds Name -> TcM thing- -> TcM (HsLocalBinds TcId, thing)+tcLocalBinds :: HsLocalBinds GhcRn -> TcM thing+ -> TcM (HsLocalBinds GhcTcId, thing) tcLocalBinds EmptyLocalBinds thing_inside = do { thing <- thing_inside@@ -371,7 +376,7 @@ -- Coerces a `t` into a dictionry for `IP "x" t`. -- co : t -> IP "x" t- toDict ipClass x ty = HsWrap $ mkWpCastR $+ toDict ipClass x ty = mkHsWrap $ mkWpCastR $ wrapIP $ mkClassPred ipClass [x,ty] {- Note [Implicit parameter untouchables]@@ -390,9 +395,9 @@ -} tcValBinds :: TopLevelFlag- -> [(RecFlag, LHsBinds Name)] -> [LSig Name]+ -> [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM thing- -> TcM ([(RecFlag, LHsBinds TcId)], thing)+ -> TcM ([(RecFlag, LHsBinds GhcTcId)], thing) tcValBinds top_lvl binds sigs thing_inside = do { let patsyns = getPatSynBinds binds@@ -405,7 +410,7 @@ -- Extend the envt right away with all the Ids -- declared with complete type signatures- -- Do not extend the TcIdBinderStack; instead+ -- Do not extend the TcBinderStack; instead -- we extend it on a per-rhs basis in tcExtendForRhs ; tcExtendSigIds top_lvl poly_ids $ do { (binds', (extra_binds', thing)) <- tcBindGroups top_lvl sig_fn prag_fn binds $ do@@ -419,8 +424,8 @@ ------------------------ tcBindGroups :: TopLevelFlag -> TcSigFun -> TcPragEnv- -> [(RecFlag, LHsBinds Name)] -> TcM thing- -> TcM ([(RecFlag, LHsBinds TcId)], thing)+ -> [(RecFlag, LHsBinds GhcRn)] -> TcM thing+ -> TcM ([(RecFlag, LHsBinds GhcTcId)], thing) -- Typecheck a whole lot of value bindings, -- one strongly-connected component at a time -- Here a "strongly connected component" has the strightforward@@ -460,8 +465,8 @@ ------------------------ tc_group :: forall thing. TopLevelFlag -> TcSigFun -> TcPragEnv- -> (RecFlag, LHsBinds Name) -> IsGroupClosed -> TcM thing- -> TcM ([(RecFlag, LHsBinds TcId)], thing)+ -> (RecFlag, LHsBinds GhcRn) -> IsGroupClosed -> TcM thing+ -> TcM ([(RecFlag, LHsBinds GhcTcId)], thing) -- Typecheck one strongly-connected component of the original program. -- We get a list of groups back, because there may@@ -495,10 +500,10 @@ isPatSyn PatSynBind{} = True isPatSyn _ = False - sccs :: [SCC (LHsBind Name)]+ sccs :: [SCC (LHsBind GhcRn)] sccs = stronglyConnCompFromEdgedVerticesUniq (mkEdges sig_fn binds) - go :: [SCC (LHsBind Name)] -> TcM (LHsBinds TcId, thing)+ go :: [SCC (LHsBind GhcRn)] -> TcM (LHsBinds GhcTcId, thing) go (scc:sccs) = do { (binds1, ids1) <- tc_scc scc ; (binds2, thing) <- tcExtendLetEnv top_lvl sig_fn closed ids1 $@@ -512,7 +517,7 @@ tc_sub_group rec_tc binds = tcPolyBinds sig_fn prag_fn Recursive rec_tc closed binds -recursivePatSynErr :: OutputableBndr name => LHsBinds name -> TcM a+recursivePatSynErr :: OutputableBndrId name => LHsBinds name -> TcM a recursivePatSynErr binds = failWithTc $ hang (text "Recursive pattern synonym definition with following bindings:")@@ -524,8 +529,8 @@ tc_single :: forall thing. TopLevelFlag -> TcSigFun -> TcPragEnv- -> LHsBind Name -> IsGroupClosed -> TcM thing- -> TcM (LHsBinds TcId, thing)+ -> LHsBind GhcRn -> IsGroupClosed -> TcM thing+ -> TcM (LHsBinds GhcTcId, thing) tc_single _top_lvl sig_fn _prag_fn (L _ (PatSynBind psb@PSB{ psb_id = L _ name })) _ thing_inside@@ -534,7 +539,7 @@ ; return (aux_binds, thing) } where- tc_pat_syn_decl :: TcM (LHsBinds TcId, TcGblEnv)+ tc_pat_syn_decl :: TcM (LHsBinds GhcTcId, TcGblEnv) tc_pat_syn_decl = case sig_fn name of Nothing -> tcInferPatSynDecl psb Just (TcPatSynSig tpsi) -> tcCheckPatSynDecl psb tpsi@@ -551,11 +556,11 @@ ------------------------ type BKey = Int -- Just number off the bindings -mkEdges :: TcSigFun -> LHsBinds Name -> [Node BKey (LHsBind Name)]+mkEdges :: TcSigFun -> LHsBinds GhcRn -> [Node BKey (LHsBind GhcRn)] -- See Note [Polymorphic recursion] in HsBinds. mkEdges sig_fn binds- = [ (bind, key, [key | n <- nonDetEltsUniqSet (bind_fvs (unLoc bind)),- Just key <- [lookupNameEnv key_map n], no_sig n ])+ = [ DigraphNode bind key [key | n <- nonDetEltsUniqSet (bind_fvs (unLoc bind)),+ Just key <- [lookupNameEnv key_map n], no_sig n ] | (bind, key) <- keyd_binds ] -- It's OK to use nonDetEltsUFM here as stronglyConnCompFromEdgedVertices@@ -577,8 +582,8 @@ -> RecFlag -- Whether it's recursive after breaking -- dependencies based on type signatures -> IsGroupClosed -- Whether the group is closed- -> [LHsBind Name] -- None are PatSynBind- -> TcM (LHsBinds TcId, [TcId])+ -> [LHsBind GhcRn] -- None are PatSynBind+ -> TcM (LHsBinds GhcTcId, [TcId]) -- Typechecks a single bunch of values bindings all together, -- and generalises them. The bunch may be only part of a recursive@@ -622,7 +627,7 @@ -- If typechecking the binds fails, then return with each -- signature-less binder given type (forall a.a), to minimise -- subsequent error messages-recoveryCode :: [Name] -> TcSigFun -> TcM (LHsBinds TcId, [Id])+recoveryCode :: [Name] -> TcSigFun -> TcM (LHsBinds GhcTcId, [Id]) recoveryCode binder_names sig_fn = do { traceTc "tcBindsWithSigs: error recovery" (ppr binder_names) ; let poly_ids = map mk_dummy binder_names@@ -648,8 +653,8 @@ :: RecFlag -- Whether it's recursive after breaking -- dependencies based on type signatures -> TcPragEnv -> TcSigFun- -> [LHsBind Name]- -> TcM (LHsBinds TcId, [TcId])+ -> [LHsBind GhcRn]+ -> TcM (LHsBinds GhcTcId, [TcId]) tcPolyNoGen rec_tc prag_fn tc_sig_fn bind_list = do { (binds', mono_infos) <- tcMonoBinds rec_tc tc_sig_fn@@ -675,8 +680,8 @@ tcPolyCheck :: TcPragEnv -> TcIdSigInfo -- Must be a complete signature- -> LHsBind Name -- Must be a FunBind- -> TcM (LHsBinds TcId, [TcId])+ -> LHsBind GhcRn -- Must be a FunBind+ -> TcM (LHsBinds GhcTcId, [TcId]) -- There is just one binding, -- it is a Funbind -- it has a complete type signature,@@ -699,7 +704,7 @@ ; (ev_binds, (co_fn, matches')) <- checkConstraints skol_info skol_tvs ev_vars $- tcExtendIdBndrs [TcIdBndr mono_id NotTopLevel] $+ tcExtendBinderStack [TcIdBndr mono_id NotTopLevel] $ tcExtendTyVarEnv2 tv_prs $ setSrcSpan loc $ tcMatchesFun (L nm_loc mono_name) matches (mkCheckExpType tau)@@ -715,20 +720,26 @@ , bind_fvs = placeHolderNamesTc , fun_tick = funBindTicks nm_loc mono_id mod prag_sigs } - abs_bind = L loc $ AbsBindsSig- { abs_sig_export = poly_id- , abs_tvs = skol_tvs- , abs_ev_vars = ev_vars- , abs_sig_prags = SpecPrags spec_prags- , abs_sig_ev_bind = ev_binds- , abs_sig_bind = L loc bind' }+ export = ABE { abe_wrap = idHsWrapper+ , abe_poly = poly_id+ , abe_mono = mono_id+ , abe_prags = SpecPrags spec_prags } + abs_bind = L loc $+ AbsBinds { abs_tvs = skol_tvs+ , abs_ev_vars = ev_vars+ , abs_ev_binds = [ev_binds]+ , abs_exports = [export]+ , abs_binds = unitBag (L loc bind')+ , abs_sig = True }+ ; return (unitBag abs_bind, [poly_id]) } tcPolyCheck _prag_fn sig bind = pprPanic "tcPolyCheck" (ppr sig $$ ppr bind) -funBindTicks :: SrcSpan -> TcId -> Module -> [LSig Name] -> [Tickish TcId]+funBindTicks :: SrcSpan -> TcId -> Module -> [LSig GhcRn]+ -> [Tickish TcId] funBindTicks loc fun_id mod sigs | (mb_cc_str : _) <- [ cc_name | L _ (SCCFunSig _ _ cc_name) <- sigs ] -- this can only be a singleton list, as duplicate pragmas are rejected@@ -769,8 +780,8 @@ -- dependencies based on type signatures -> TcPragEnv -> TcSigFun -> Bool -- True <=> apply the monomorphism restriction- -> [LHsBind Name]- -> TcM (LHsBinds TcId, [TcId])+ -> [LHsBind GhcRn]+ -> TcM (LHsBinds GhcTcId, [TcId]) tcPolyInfer rec_tc prag_fn tc_sig_fn mono bind_list = do { (tclvl, wanted, (binds', mono_infos)) <- pushLevelAndCaptureConstraints $@@ -796,7 +807,8 @@ abs_bind = L loc $ AbsBinds { abs_tvs = qtvs , abs_ev_vars = givens, abs_ev_binds = [ev_binds]- , abs_exports = exports, abs_binds = binds' }+ , abs_exports = exports, abs_binds = binds'+ , abs_sig = False } ; traceTc "Binding:" (ppr (poly_ids `zip` map idType poly_ids)) ; return (unitBag abs_bind, poly_ids) }@@ -808,7 +820,7 @@ -- when typechecking the bindings -> [TyVar] -> TcThetaType -- Both already zonked -> MonoBindInfo- -> TcM (ABExport Id)+ -> TcM (ABExport GhcTc) -- Only called for generalisation plan InferGen, not by CheckGen or NoGen -- -- mkExport generates exports with@@ -844,7 +856,7 @@ ; wrap <- if sel_poly_ty `eqType` poly_ty -- NB: eqType ignores visibility then return idHsWrapper -- Fast path; also avoids complaint when we infer- -- an ambiguouse type and have AllowAmbiguousType+ -- an ambiguous type and have AllowAmbiguousType -- e..g infer x :: forall a. F a -> Int else addErrCtxtM (mk_impedance_match_msg mono_info sel_poly_ty poly_ty) $ tcSubType_NC sig_ctxt sel_poly_ty poly_ty@@ -855,9 +867,9 @@ ; return (ABE { abe_wrap = wrap -- abe_wrap :: idType poly_id ~ (forall qtvs. theta => mono_ty)- , abe_poly = poly_id- , abe_mono = mono_id- , abe_prags = SpecPrags spec_prags}) }+ , abe_poly = poly_id+ , abe_mono = mono_id+ , abe_prags = SpecPrags spec_prags }) } where prag_sigs = lookupPragEnv prag_fn poly_name sig_ctxt = InfSigCtxt poly_name@@ -926,64 +938,90 @@ , sig_inst_wcx = wcx , sig_inst_theta = annotated_theta , sig_inst_skols = annotated_tvs }))- | Nothing <- wcx- = do { annotated_theta <- zonkTcTypes annotated_theta- ; let free_tvs = closeOverKinds (tyCoVarsOfTypes annotated_theta- `unionVarSet` tau_tvs)- ; traceTc "ciq" (vcat [ ppr sig, ppr annotated_theta, ppr free_tvs])- ; psig_qtvs <- mk_psig_qtvs annotated_tvs- ; return (mk_final_qtvs psig_qtvs free_tvs, annotated_theta) }+ = -- Choose quantifiers for a partial type signature+ do { psig_qtv_prs <- zonkSigTyVarPairs annotated_tvs - | Just wc_var <- wcx- = do { annotated_theta <- zonkTcTypes annotated_theta- ; let free_tvs = closeOverKinds (growThetaTyVars inferred_theta seed_tvs)- -- growThetaVars just like the no-type-sig case- -- Omitting this caused #12844- seed_tvs = tyCoVarsOfTypes annotated_theta -- These are put there- `unionVarSet` tau_tvs -- by the user+ -- Check whether the quantified variables of the+ -- partial signature have been unified together+ -- See Note [Quantified variables in partial type signatures]+ ; mapM_ report_dup_sig_tv_err (findDupSigTvs psig_qtv_prs) - ; psig_qtvs <- mk_psig_qtvs annotated_tvs- ; let my_qtvs = mk_final_qtvs psig_qtvs free_tvs- keep_me = psig_qtvs `unionVarSet` free_tvs- my_theta = pickCapturedPreds keep_me inferred_theta+ -- Check whether a quantified variable of the partial type+ -- signature is not actually quantified. How can that happen?+ -- See Note [Quantification and partial signatures] Wrinkle 4+ -- in TcSimplify+ ; mapM_ report_mono_sig_tv_err [ n | (n,tv) <- psig_qtv_prs+ , not (tv `elem` qtvs) ] - -- Fill in the extra-constraints wildcard hole with inferred_theta,- -- so that the Hole constraint we have already emitted (in tcHsPartialSigType)- -- can report what filled it in.- -- NB: my_theta already includes all the annotated constraints- inferred_diff = [ pred- | pred <- my_theta- , all (not . (`eqType` pred)) annotated_theta ]- ; ctuple <- mk_ctuple inferred_diff- ; writeMetaTyVar wc_var ctuple+ ; let psig_qtvs = mkVarSet (map snd psig_qtv_prs) - ; traceTc "completeTheta" $- vcat [ ppr sig- , ppr annotated_theta, ppr inferred_theta- , ppr inferred_diff ]- ; return (my_qtvs, my_theta) }+ ; annotated_theta <- zonkTcTypes annotated_theta+ ; (free_tvs, my_theta) <- choose_psig_context psig_qtvs annotated_theta wcx - | otherwise -- A complete type signature is dealt with in mkInferredPolyId- = pprPanic "chooseInferredQuantifiers" (ppr sig)+ ; let keep_me = free_tvs `unionVarSet` psig_qtvs+ final_qtvs = [ mkTyVarBinder vis tv+ | tv <- qtvs -- Pulling from qtvs maintains original order+ , tv `elemVarSet` keep_me+ , let vis | tv `elemVarSet` psig_qtvs = Specified+ | otherwise = Inferred ] + ; return (final_qtvs, my_theta) } where- mk_final_qtvs psig_qtvs free_tvs- = [ mkTyVarBinder vis tv- | tv <- qtvs -- Pulling from qtvs maintains original order- , tv `elemVarSet` keep_me- , let vis | tv `elemVarSet` psig_qtvs = Specified- | otherwise = Inferred ]- where- keep_me = free_tvs `unionVarSet` psig_qtvs+ report_dup_sig_tv_err (n1,n2)+ | PartialSig { psig_name = fn_name, psig_hs_ty = hs_ty } <- sig+ = addErrTc (hang (text "Couldn't match" <+> quotes (ppr n1)+ <+> text "with" <+> quotes (ppr n2))+ 2 (hang (text "both bound by the partial type signature:")+ 2 (ppr fn_name <+> dcolon <+> ppr hs_ty))) + | otherwise -- Can't happen; by now we know it's a partial sig+ = pprPanic "report_sig_tv_err" (ppr sig)++ report_mono_sig_tv_err n+ | PartialSig { psig_name = fn_name, psig_hs_ty = hs_ty } <- sig+ = addErrTc (hang (text "Can't quantify over" <+> quotes (ppr n))+ 2 (hang (text "bound by the partial type signature:")+ 2 (ppr fn_name <+> dcolon <+> ppr hs_ty)))+ | otherwise -- Can't happen; by now we know it's a partial sig+ = pprPanic "report_sig_tv_err" (ppr sig)++ choose_psig_context :: VarSet -> TcThetaType -> Maybe TcTyVar+ -> TcM (VarSet, TcThetaType)+ choose_psig_context _ annotated_theta Nothing+ = do { let free_tvs = closeOverKinds (tyCoVarsOfTypes annotated_theta+ `unionVarSet` tau_tvs)+ ; return (free_tvs, annotated_theta) }++ choose_psig_context psig_qtvs annotated_theta (Just wc_var)+ = do { let free_tvs = closeOverKinds (growThetaTyVars inferred_theta seed_tvs)+ -- growThetaVars just like the no-type-sig case+ -- Omitting this caused #12844+ seed_tvs = tyCoVarsOfTypes annotated_theta -- These are put there+ `unionVarSet` tau_tvs -- by the user++ ; let keep_me = psig_qtvs `unionVarSet` free_tvs+ my_theta = pickCapturedPreds keep_me inferred_theta++ -- Fill in the extra-constraints wildcard hole with inferred_theta,+ -- so that the Hole constraint we have already emitted+ -- (in tcHsPartialSigType) can report what filled it in.+ -- NB: my_theta already includes all the annotated constraints+ ; let inferred_diff = [ pred+ | pred <- my_theta+ , all (not . (`eqType` pred)) annotated_theta ]+ ; ctuple <- mk_ctuple inferred_diff+ ; writeMetaTyVar wc_var ctuple++ ; traceTc "completeTheta" $+ vcat [ ppr sig+ , ppr annotated_theta, ppr inferred_theta+ , ppr inferred_diff ]+ ; return (free_tvs, my_theta) }+ mk_ctuple preds = return (mkBoxedTupleTy preds) -- Hack alert! See TcHsType: -- Note [Extra-constraint holes in partial type signatures] - mk_psig_qtvs :: [(Name,TcTyVar)] -> TcM TcTyVarSet- mk_psig_qtvs annotated_tvs- = do { psig_qtvs <- mapM (zonkTcTyVarToTyVar . snd) annotated_tvs- ; return (mkVarSet psig_qtvs) } mk_impedance_match_msg :: MonoBindInfo -> TcType -> TcType@@ -1081,6 +1119,28 @@ wildcard; that is, we don't apply the MR if you write f3 :: _ => blah +Note [Quantified variables in partial type signatures]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ f :: forall a. a -> a -> _+ f x y = g x y+ g :: forall b. b -> b -> _+ g x y = [x, y]++Here, 'f' and 'g' are mutually recursive, and we end up unifying 'a' and 'b'+together, which is fine. So we bind 'a' and 'b' to SigTvs, which can then+unify with each other.++But now consider:+ f :: forall a b. a -> b -> _+ f x y = [x, y]++We want to get an error from this, because 'a' and 'b' get unified.+So we make a test, one per parital signature, to check that the+explicitly-quantified type variables have not been unified together.+Trac #14449 showed this up.++ Note [Validity of inferred types] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We need to check inferred type for validity, in case it uses language@@ -1141,7 +1201,7 @@ * * ********************************************************************* -} -tcVectDecls :: [LVectDecl Name] -> TcM ([LVectDecl TcId])+tcVectDecls :: [LVectDecl GhcRn] -> TcM ([LVectDecl GhcTcId]) tcVectDecls decls = do { decls' <- mapM (wrapLocM tcVect) decls ; let ids = [lvectDeclName decl | decl <- decls', not $ lvectInstDecl decl]@@ -1151,13 +1211,13 @@ ; return decls' } where- reportVectDups (first:_second:_more)+ reportVectDups (first :| (_second:_more)) = addErrAt (getSrcSpan first) $ text "Duplicate vectorisation declarations for" <+> ppr first reportVectDups _ = return () ---------------tcVect :: VectDecl Name -> TcM (VectDecl TcId)+tcVect :: VectDecl GhcRn -> TcM (VectDecl GhcTcId) -- FIXME: We can't typecheck the expression of a vectorisation declaration against the vectorised -- type of the original definition as this requires internals of the vectoriser not available -- during type checking. Instead, constrain the rhs of a vectorisation declaration to be a single@@ -1252,8 +1312,8 @@ -- i.e. the binders are mentioned in their RHSs, and -- we are not rescued by a type signature -> TcSigFun -> LetBndrSpec- -> [LHsBind Name]- -> TcM (LHsBinds TcId, [MonoBindInfo])+ -> [LHsBind GhcRn]+ -> TcM (LHsBinds GhcTcId, [MonoBindInfo]) tcMonoBinds is_rec sig_fn no_gen [ L b_loc (FunBind { fun_id = L nm_loc name, fun_matches = matches, bind_fvs = fvs })]@@ -1272,7 +1332,7 @@ <- tcInferInst $ \ exp_ty -> -- tcInferInst: see TcUnify, -- Note [Deep instantiation of InferResult]- tcExtendIdBndrs [TcIdBndr_ExpType name exp_ty NotTopLevel] $+ tcExtendBinderStack [TcIdBndr_ExpType name exp_ty NotTopLevel] $ -- We extend the error context even for a non-recursive -- function so that in type error messages we show the -- type of the thing whose rhs we are type checking@@ -1327,10 +1387,11 @@ -- it; hence the TcMonoBind data type in which the LHS is done but the RHS isn't data TcMonoBind -- Half completed; LHS done, RHS not done- = TcFunBind MonoBindInfo SrcSpan (MatchGroup Name (LHsExpr Name))- | TcPatBind [MonoBindInfo] (LPat TcId) (GRHSs Name (LHsExpr Name)) TcSigmaType+ = TcFunBind MonoBindInfo SrcSpan (MatchGroup GhcRn (LHsExpr GhcRn))+ | TcPatBind [MonoBindInfo] (LPat GhcTcId) (GRHSs GhcRn (LHsExpr GhcRn))+ TcSigmaType -tcLhs :: TcSigFun -> LetBndrSpec -> HsBind Name -> TcM TcMonoBind+tcLhs :: TcSigFun -> LetBndrSpec -> HsBind GhcRn -> TcM TcMonoBind -- Only called with plan InferGen (LetBndrSpec = LetLclBndr) -- or NoGen (LetBndrSpec = LetGblBndr) -- CheckGen is used only for functions with a complete type signature,@@ -1417,7 +1478,7 @@ = newLetBndr no_gen name tau --------------------tcRhs :: TcMonoBind -> TcM (HsBind TcId)+tcRhs :: TcMonoBind -> TcM (HsBind GhcTcId) tcRhs (TcFunBind info@(MBI { mbi_sig = mb_sig, mbi_mono_id = mono_id }) loc matches) = tcExtendIdBinderStackForRhs [info] $@@ -1459,7 +1520,7 @@ thing_inside tcExtendIdBinderStackForRhs :: [MonoBindInfo] -> TcM a -> TcM a--- Extend the TcIdBinderStack for the RHS of the binding, with+-- Extend the TcBinderStack for the RHS of the binding, with -- the monomorphic Id. That way, if we have, say -- f = \x -> blah -- and something goes wrong in 'blah', we get a "relevant binding"@@ -1468,12 +1529,12 @@ -- f :: forall a. [a] -> [a] -- f x = True -- We can't unify True with [a], and a relevant binding is f :: [a] -> [a]--- If we had the *polymorphic* version of f in the TcIdBinderStack, it+-- If we had the *polymorphic* version of f in the TcBinderStack, it -- would not be reported as relevant, because its type is closed tcExtendIdBinderStackForRhs infos thing_inside- = tcExtendIdBndrs [ TcIdBndr mono_id NotTopLevel- | MBI { mbi_mono_id = mono_id } <- infos ]- thing_inside+ = tcExtendBinderStack [ TcIdBndr mono_id NotTopLevel+ | MBI { mbi_mono_id = mono_id } <- infos ]+ thing_inside -- NotTopLevel: it's a monomorphic binding ---------------------@@ -1605,9 +1666,9 @@ | InferGen -- Implicit generalisation; there is an AbsBinds Bool -- True <=> apply the MR; generalise only unconstrained type vars - | CheckGen (LHsBind Name) TcIdSigInfo+ | CheckGen (LHsBind GhcRn) TcIdSigInfo -- One FunBind with a signature- -- Explicit generalisation; there is an AbsBindsSig+ -- Explicit generalisation -- A consequence of the no-AbsBinds choice (NoGen) is that there is -- no "polymorphic Id" and "monmomorphic Id"; there is just the one@@ -1618,7 +1679,7 @@ ppr (CheckGen _ s) = text "CheckGen" <+> ppr s decideGeneralisationPlan- :: DynFlags -> [LHsBind Name] -> IsGroupClosed -> TcSigFun+ :: DynFlags -> [LHsBind GhcRn] -> IsGroupClosed -> TcSigFun -> GeneralisationPlan decideGeneralisationPlan dflags lbinds closed sig_fn | has_partial_sigs = InferGen (and partial_sig_mrs)@@ -1629,7 +1690,7 @@ binds = map unLoc lbinds partial_sig_mrs :: [Bool]- -- One for each parital signature (so empty => no partial sigs)+ -- One for each partial signature (so empty => no partial sigs) -- The Bool is True if the signature has no constraint context -- so we should apply the MR -- See Note [Partial type signatures and generalisation]@@ -1664,18 +1725,15 @@ restricted (VarBind { var_id = v }) = no_sig v restricted (FunBind { fun_id = v, fun_matches = m }) = restricted_match m && no_sig (unLoc v)- restricted (PatSynBind {}) = panic "isRestrictedGroup/unrestricted PatSynBind"- restricted (AbsBinds {}) = panic "isRestrictedGroup/unrestricted AbsBinds"- restricted (AbsBindsSig {}) = panic "isRestrictedGroup/unrestricted AbsBindsSig"+ restricted b = pprPanic "isRestrictedGroup/unrestricted" (ppr b) - restricted_match (MG { mg_alts = L _ (L _ (Match _ [] _ _) : _ )}) = True- restricted_match _ = False+ restricted_match mg = matchGroupArity mg == 0 -- No args => like a pattern binding -- Some args => a function binding no_sig n = not (hasCompleteSig sig_fn n) -isClosedBndrGroup :: TcTypeEnv -> Bag (LHsBind Name) -> IsGroupClosed+isClosedBndrGroup :: TcTypeEnv -> Bag (LHsBind GhcRn) -> IsGroupClosed isClosedBndrGroup type_env binds = IsGroupClosed fv_env type_closed where@@ -1684,7 +1742,7 @@ fv_env :: NameEnv NameSet fv_env = mkNameEnv $ concatMap (bindFvs . unLoc) binds - bindFvs :: HsBindLR Name idR -> [(Name, NameSet)]+ bindFvs :: HsBindLR GhcRn idR -> [(Name, NameSet)] bindFvs (FunBind { fun_id = L _ f, bind_fvs = fvs }) = let open_fvs = filterNameSet (not . is_closed) fvs in [(f, open_fvs)]@@ -1732,7 +1790,7 @@ -- This one is called on LHS, when pat and grhss are both Name -- and on RHS, when pat is TcId and grhss is still Name-patMonoBindsCtxt :: (OutputableBndrId id, Outputable body)- => LPat id -> GRHSs Name body -> SDoc+patMonoBindsCtxt :: (SourceTextX p, OutputableBndrId p, Outputable body)+ => LPat p -> GRHSs GhcRn body -> SDoc patMonoBindsCtxt pat grhss = hang (text "In a pattern binding:") 2 (pprPatBind pat grhss)
typecheck/TcCanonical.hs view
@@ -4,11 +4,14 @@ canonicalize, unifyDerived, makeSuperClasses, maybeSym,- StopOrContinue(..), stopWith, continueWith+ StopOrContinue(..), stopWith, continueWith,+ solveCallStack -- For TcSimplify ) where #include "HsVersions.h" +import GhcPrelude+ import TcRnTypes import TcUnify( swapOverTyVars, metaTyVarUpdateOK ) import TcType@@ -24,11 +27,11 @@ import FamInst ( tcTopNormaliseNewTypeTF_maybe ) import Var import VarEnv( mkInScopeSet )-import VarSet( extendVarSetList ) import Outputable import DynFlags( DynFlags ) import NameSet import RdrName+import HsTypes( HsIPName(..) ) import Pair import Util@@ -75,11 +78,19 @@ -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ canonicalize :: Ct -> TcS (StopOrContinue Ct)-canonicalize ct@(CNonCanonical { cc_ev = ev })- = do { traceTcS "canonicalize (non-canonical)" (ppr ct)- ; {-# SCC "canEvVar" #-}- canEvNC ev }+canonicalize (CNonCanonical { cc_ev = ev })+ = {-# SCC "canNC" #-}+ case classifyPredType (ctEvPred ev) of+ ClassPred cls tys -> do traceTcS "canEvNC:cls" (ppr cls <+> ppr tys)+ canClassNC ev cls tys+ EqPred eq_rel ty1 ty2 -> do traceTcS "canEvNC:eq" (ppr ty1 $$ ppr ty2)+ canEqNC ev eq_rel ty1 ty2+ IrredPred {} -> do traceTcS "canEvNC:irred" (ppr (ctEvPred ev))+ canIrred ev +canonicalize (CIrredCan { cc_ev = ev })+ = canIrred ev+ canonicalize (CDictCan { cc_ev = ev, cc_class = cls , cc_tyargs = xis, cc_pend_sc = pend_sc }) = {-# SCC "canClass" #-}@@ -101,21 +112,9 @@ = {-# SCC "canEqLeafFunEq" #-} canCFunEqCan ev fn xis1 fsk -canonicalize (CIrredEvCan { cc_ev = ev })- = canIrred ev canonicalize (CHoleCan { cc_ev = ev, cc_hole = hole }) = canHole ev hole -canEvNC :: CtEvidence -> TcS (StopOrContinue Ct)--- Called only for non-canonical EvVars-canEvNC ev- = case classifyPredType (ctEvPred ev) of- ClassPred cls tys -> do traceTcS "canEvNC:cls" (ppr cls <+> ppr tys)- canClassNC ev cls tys- EqPred eq_rel ty1 ty2 -> do traceTcS "canEvNC:eq" (ppr ty1 $$ ppr ty2)- canEqNC ev eq_rel ty1 ty2- IrredPred {} -> do traceTcS "canEvNC:irred" (ppr (ctEvPred ev))- canIrred ev {- ************************************************************************ * *@@ -126,18 +125,55 @@ canClassNC :: CtEvidence -> Class -> [Type] -> TcS (StopOrContinue Ct) -- "NC" means "non-canonical"; that is, we have got here--- from a NonCanonical constrataint, not from a CDictCan+-- from a NonCanonical constraint, not from a CDictCan -- Precondition: EvVar is class evidence canClassNC ev cls tys | isGiven ev -- See Note [Eagerly expand given superclasses] = do { sc_cts <- mkStrictSuperClasses ev cls tys ; emitWork sc_cts ; canClass ev cls tys False }++ | isWanted ev+ , Just ip_name <- isCallStackPred cls tys+ , OccurrenceOf func <- ctLocOrigin loc+ -- If we're given a CallStack constraint that arose from a function+ -- call, we need to push the current call-site onto the stack instead+ -- of solving it directly from a given.+ -- See Note [Overview of implicit CallStacks] in TcEvidence+ -- and Note [Solving CallStack constraints] in TcSMonad+ = do { -- First we emit a new constraint that will capture the+ -- given CallStack.+ ; let new_loc = setCtLocOrigin loc (IPOccOrigin (HsIPName ip_name))+ -- We change the origin to IPOccOrigin so+ -- this rule does not fire again.+ -- See Note [Overview of implicit CallStacks]++ ; new_ev <- newWantedEvVarNC new_loc pred++ -- Then we solve the wanted by pushing the call-site+ -- onto the newly emitted CallStack+ ; let ev_cs = EvCsPushCall func (ctLocSpan loc) (ctEvTerm new_ev)+ ; solveCallStack ev ev_cs++ ; canClass new_ev cls tys False }+ | otherwise = canClass ev cls tys (has_scs cls)+ where has_scs cls = not (null (classSCTheta cls))+ loc = ctEvLoc ev+ pred = ctEvPred ev +solveCallStack :: CtEvidence -> EvCallStack -> TcS ()+-- Also called from TcSimplify when defaulting call stacks+solveCallStack ev ev_cs = do+ -- We're given ev_cs :: CallStack, but the evidence term should be a+ -- dictionary, so we have to coerce ev_cs to a dictionary for+ -- `IP ip CallStack`. See Note [Overview of implicit CallStacks]+ let ev_tm = mkEvCast (EvCallStack ev_cs) (wrapIP (ctEvPred ev))+ setWantedEvBind (ctEvEvId ev) ev_tm+ canClass :: CtEvidence -> Class -> [Type] -> Bool -- True <=> un-explored superclasses@@ -450,25 +486,35 @@ canIrred :: CtEvidence -> TcS (StopOrContinue Ct) -- Precondition: ty not a tuple and no other evidence form-canIrred old_ev- = do { let old_ty = ctEvPred old_ev- ; traceTcS "can_pred" (text "IrredPred = " <+> ppr old_ty)- ; (xi,co) <- flatten FM_FlattenAll old_ev old_ty -- co :: xi ~ old_ty- ; rewriteEvidence old_ev xi co `andWhenContinue` \ new_ev ->+canIrred ev+ | EqPred eq_rel ty1 ty2 <- classifyPredType pred+ = -- For insolubles (all of which are equalities, do /not/ flatten the arguments+ -- In Trac #14350 doing so led entire-unnecessary and ridiculously large+ -- type function expansion. Instead, canEqNC just applies+ -- the substitution to the predicate, and may do decomposition;+ -- e.g. a ~ [a], where [G] a ~ [Int], can decompose+ canEqNC ev eq_rel ty1 ty2++ | otherwise+ = do { traceTcS "can_pred" (text "IrredPred = " <+> ppr pred)+ ; (xi,co) <- flatten FM_FlattenAll ev pred -- co :: xi ~ pred+ ; rewriteEvidence ev xi co `andWhenContinue` \ new_ev -> do { -- Re-classify, in case flattening has improved its shape ; case classifyPredType (ctEvPred new_ev) of ClassPred cls tys -> canClassNC new_ev cls tys EqPred eq_rel ty1 ty2 -> canEqNC new_ev eq_rel ty1 ty2 _ -> continueWith $- CIrredEvCan { cc_ev = new_ev } } }+ mkIrredCt new_ev } }+ where+ pred = ctEvPred ev canHole :: CtEvidence -> Hole -> TcS (StopOrContinue Ct) canHole ev hole = do { let ty = ctEvPred ev ; (xi,co) <- flatten FM_SubstOnly ev ty -- co :: xi ~ ty ; rewriteEvidence ev xi co `andWhenContinue` \ new_ev ->- do { emitInsoluble (CHoleCan { cc_ev = new_ev- , cc_hole = hole })+ do { updInertIrreds (`snocCts` (CHoleCan { cc_ev = new_ev+ , cc_hole = hole })) ; stopWith new_ev "Emit insoluble hole" } } {-@@ -563,6 +609,22 @@ | Just stuff2 <- tcTopNormaliseNewTypeTF_maybe envs rdr_env ty2 = can_eq_newtype_nc ev IsSwapped ty2 stuff2 ty1 ps_ty1 +-- Now, check for tyvars. This must happen before CastTy because we need+-- to catch casted tyvars, as the flattener might produce these,+-- due to the fact that flattened types have flattened kinds.+-- See Note [Flattening].+-- Note that there can be only one cast on the tyvar because this will+-- run after the "get rid of casts" case of can_eq_nc' function on the+-- not-yet-flattened types.+-- NB: pattern match on True: we want only flat types sent to canEqTyVar.+-- See also Note [No top-level newtypes on RHS of representational equalities]+can_eq_nc' True _rdr_env _envs ev eq_rel ty1 ps_ty1 ty2 ps_ty2+ | Just (tv1, co1) <- getCastedTyVar_maybe ty1+ = canEqTyVar ev eq_rel NotSwapped tv1 co1 ps_ty1 ty2 ps_ty2+can_eq_nc' True _rdr_env _envs ev eq_rel ty1 ps_ty1 ty2 ps_ty2+ | Just (tv2, co2) <- getCastedTyVar_maybe ty2+ = canEqTyVar ev eq_rel IsSwapped tv2 co2 ps_ty2 ty1 ps_ty1+ -- Then, get rid of casts can_eq_nc' flat _rdr_env _envs ev eq_rel (CastTy ty1 co1) _ ty2 ps_ty2 = canEqCast flat ev eq_rel NotSwapped ty1 co1 ty2 ps_ty2@@ -609,14 +671,6 @@ `andWhenContinue` \ new_ev -> can_eq_nc' True rdr_env envs new_ev eq_rel xi1 xi1 xi2 xi2 } --- Type variable on LHS or RHS are last.--- NB: pattern match on True: we want only flat types sent to canEqTyVar.--- See also Note [No top-level newtypes on RHS of representational equalities]-can_eq_nc' True _rdr_env _envs ev eq_rel (TyVarTy tv1) ps_ty1 ty2 ps_ty2- = canEqTyVar ev eq_rel NotSwapped tv1 ps_ty1 ty2 ps_ty2-can_eq_nc' True _rdr_env _envs ev eq_rel ty1 ps_ty1 (TyVarTy tv2) ps_ty2- = canEqTyVar ev eq_rel IsSwapped tv2 ps_ty2 ty1 ps_ty1- -- We've flattened and the types don't match. Give up. can_eq_nc' True _rdr_env _envs ev _eq_rel _ ps_ty1 _ ps_ty2 = do { traceTcS "can_eq_nc' catch-all case" (ppr ps_ty1 $$ ppr ps_ty2)@@ -636,8 +690,7 @@ can_eq_nc_forall ev eq_rel s1 s2 | CtWanted { ctev_loc = loc, ctev_dest = orig_dest } <- ev- = do { let free_tvs1 = tyCoVarsOfType s1- free_tvs2 = tyCoVarsOfType s2+ = do { let free_tvs = tyCoVarsOfTypes [s1,s2] (bndrs1, phi1) = tcSplitForAllTyVarBndrs s1 (bndrs2, phi2) = tcSplitForAllTyVarBndrs s2 ; if not (equalLength bndrs1 bndrs2)@@ -648,7 +701,7 @@ ; canEqHardFailure ev s1 s2 } else do { traceTcS "Creating implication for polytype equality" $ ppr ev- ; let empty_subst1 = mkEmptyTCvSubst $ mkInScopeSet free_tvs1+ ; let empty_subst1 = mkEmptyTCvSubst $ mkInScopeSet free_tvs ; (subst1, skol_tvs) <- tcInstSkolTyVarsX empty_subst1 $ binderVars bndrs1 @@ -674,8 +727,7 @@ go _ _ _ = panic "cna_eq_nc_forall" -- case (s:ss) [] - empty_subst2 = mkEmptyTCvSubst $ mkInScopeSet $- free_tvs2 `extendVarSetList` skol_tvs+ empty_subst2 = mkEmptyTCvSubst (getTCvInScope subst1) ; (implic, _ev_binds, all_co) <- buildImplication skol_info skol_tvs [] $ go skol_tvs empty_subst2 bndrs2@@ -777,7 +829,8 @@ -> do { cts <- readTcRef ref ; case cts of Flexi -> give_up- Indirect ty' -> unSwap swapped go ty' ty }+ Indirect ty' -> do { trace_indirect tv ty'+ ; unSwap swapped go ty' ty } } _ -> give_up where give_up = return $ Left $ unSwap swapped Pair (mkTyVarTy tv) ty@@ -790,12 +843,17 @@ then go ty1' ty2' else return $ Left (Pair (TyVarTy tv1) (TyVarTy tv2)) } + trace_indirect tv ty+ = traceTcS "Following filled tyvar (zonk_eq_types)"+ (ppr tv <+> equals <+> ppr ty)+ quick_zonk tv = case tcTyVarDetails tv of MetaTv { mtv_ref = ref } -> do { cts <- readTcRef ref ; case cts of Flexi -> return (TyVarTy tv, False)- Indirect ty' -> return (ty', True) }+ Indirect ty' -> do { trace_indirect tv ty'+ ; return (ty', True) } } _ -> return (TyVarTy tv, False) -- This happens for type families, too. But recall that failure@@ -865,7 +923,7 @@ Consider trying to prove (f a) ~R (f a). The AppTys in there can't be decomposed, because representational equality isn't congruent with respect to AppTy. So, when canonicalising the equality above, we get stuck and-would normally produce a CIrredEvCan. However, we really do want to+would normally produce a CIrredCan. However, we really do want to be able to solve (f a) ~R (f a). So, in the representational case only, we do a reflexivity check. @@ -912,7 +970,7 @@ -- See Note [Decomposing equality], note {4} can_eq_app ev ReprEq _ _ _ _ = do { traceTcS "failing to decompose representational AppTy equality" (ppr ev)- ; continueWith (CIrredEvCan { cc_ev = ev }) }+ ; continueWith (mkIrredCt ev) } -- no need to call canEqFailure, because that flattens, and the -- types involved here are already flat @@ -922,7 +980,10 @@ ; stopWith ev "Decomposed [D] AppTy" } | CtWanted { ctev_dest = dest, ctev_loc = loc } <- ev = do { co_s <- unifyWanted loc Nominal s1 s2- ; co_t <- unifyWanted loc Nominal t1 t2+ ; let arg_loc+ | isNextArgVisible s1 = loc+ | otherwise = updateCtLocOrigin loc toInvisibleOrigin+ ; co_t <- unifyWanted arg_loc Nominal t1 t2 ; let co = mkAppCo co_s co_t ; setWantedEq dest co ; stopWith ev "Decomposed [W] AppTy" }@@ -970,7 +1031,7 @@ -- See Note [Decomposing TyConApps] canTyConApp ev eq_rel tc1 tys1 tc2 tys2 | tc1 == tc2- , length tys1 == length tys2+ , tys1 `equalLength` tys2 = do { inerts <- getTcSInerts ; if can_decompose inerts then do { traceTcS "canTyConApp"@@ -982,7 +1043,7 @@ -- See Note [Skolem abstract data] (at tyConSkolem) | tyConSkolem tc1 || tyConSkolem tc2 = do { traceTcS "canTyConApp: skolem abstract" (ppr tc1 $$ ppr tc2)- ; continueWith (CIrredEvCan { cc_ev = ev }) }+ ; continueWith (mkIrredCt ev) } -- Fail straight away for better error messages -- See Note [Use canEqFailure in canDecomposableTyConApp]@@ -1216,14 +1277,17 @@ -- the following makes a better distinction between "kind" and "type" -- in error messages bndrs = tyConBinders tc- kind_loc = toKindLoc loc is_kinds = map isNamedTyConBinder bndrs- new_locs | Just KindLevel <- ctLocTypeOrKind_maybe loc- = repeat loc- | otherwise- = map (\is_kind -> if is_kind then kind_loc else loc) is_kinds+ is_viss = map isVisibleTyConBinder bndrs + kind_xforms = map (\is_kind -> if is_kind then toKindLoc else id) is_kinds+ vis_xforms = map (\is_vis -> if is_vis then id+ else flip updateCtLocOrigin toInvisibleOrigin)+ is_viss + -- zipWith3 (.) composes its first two arguments and applies it to the third+ new_locs = zipWith3 (.) kind_xforms vis_xforms (repeat loc)+ -- | Call when canonicalizing an equality fails, but if the equality is -- representational, there is some hope for the future. -- Examples in Note [Use canEqFailure in canDecomposableTyConApp]@@ -1241,7 +1305,7 @@ vcat [ ppr ev, ppr ty1, ppr ty2, ppr xi1, ppr xi2 ] ; rewriteEqEvidence ev NotSwapped xi1 xi2 co1 co2 `andWhenContinue` \ new_ev ->- continueWith (CIrredEvCan { cc_ev = new_ev }) }+ continueWith (mkIrredCt new_ev) } -- | Call when canonicalizing an equality fails with utterly no hope. canEqHardFailure :: CtEvidence@@ -1252,8 +1316,7 @@ ; (s2, co2) <- flatten FM_SubstOnly ev ty2 ; rewriteEqEvidence ev NotSwapped s1 s2 co1 co2 `andWhenContinue` \ new_ev ->- do { emitInsoluble (mkNonCanonical new_ev)- ; stopWith new_ev "Definitely not equal" }}+ continueWith (mkInsolubleCt new_ev) } {- Note [Decomposing TyConApps]@@ -1299,7 +1362,7 @@ all the way down, so that it accurately reflects (a) the mutable reference substitution in force at start of solving (b) any ty-binds in force at this point in solving-See Note [Kick out insolubles] in TcSMonad.+See Note [Rewrite insolubles] in TcSMonad. And if we don't do this there is a bad danger that TcSimplify.applyTyVarDefaulting will find a variable that has in fact been substituted.@@ -1350,26 +1413,12 @@ is a bad thing, but (a ~R N a) for a newtype N might be just fine. This means also that (a ~ b a) might be fine, because `b` might become a newtype. -So, we must check: does tv1 appear in xi2 under any type constructor that-is generative w.r.t. representational equality? That's what isTyVarUnderDatatype-does. (The other name I considered, isTyVarUnderTyConGenerativeWrtReprEq was-a bit verbose. And the shorter name gets the point across.)+So, we must check: does tv1 appear in xi2 under any type constructor+that is generative w.r.t. representational equality? That's what+isInsolubleOccursCheck does. See also #10715, which induced this addition. -Note [No derived kind equalities]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we're working with a heterogeneous derived equality-- [D] (t1 :: k1) ~ (t2 :: k2)--we want to homogenise to establish the kind invariant on CTyEqCans.-But we can't emit [D] k1 ~ k2 because we wouldn't then be able to-use the evidence in the homogenised types. So we emit a wanted-constraint, because we do really need the evidence here.--Thus: no derived kind equalities.- -} canCFunEqCan :: CtEvidence@@ -1397,75 +1446,143 @@ --------------------- canEqTyVar :: CtEvidence -- ev :: lhs ~ rhs -> EqRel -> SwapFlag- -> TcTyVar -> TcType -- lhs: already flat, not a cast- -> TcType -> TcType -- rhs: already flat, not a cast+ -> TcTyVar -> CoercionN -- tv1 |> co1+ -> TcType -- lhs: pretty lhs, already flat+ -> TcType -> TcType -- rhs: already flat -> TcS (StopOrContinue Ct)-canEqTyVar ev eq_rel swapped tv1 ps_ty1 (TyVarTy tv2) _- | tv1 == tv2- = canEqReflexive ev eq_rel ps_ty1+canEqTyVar ev eq_rel swapped tv1 co1 ps_ty1 xi2 ps_xi2+ | k1 `eqType` k2+ = canEqTyVarHomo ev eq_rel swapped tv1 co1 ps_ty1 xi2 ps_xi2 - | swapOverTyVars tv1 tv2+ -- See Note [Equalities with incompatible kinds]+ | CtGiven { ctev_evar = evar } <- ev+ -- unswapped: tm :: (lhs :: k1) ~ (rhs :: k2)+ -- swapped : tm :: (rhs :: k2) ~ (lhs :: k1)+ = do { kind_ev_id <- newBoundEvVarId kind_pty+ (EvCoercion $+ if isSwapped swapped+ then mkTcSymCo $ mkTcKindCo $ mkTcCoVarCo evar+ else mkTcKindCo $ mkTcCoVarCo evar)+ -- kind_ev_id :: (k1 :: *) ~ (k2 :: *) (whether swapped or not)+ ; let kind_ev = CtGiven { ctev_pred = kind_pty+ , ctev_evar = kind_ev_id+ , ctev_loc = kind_loc }+ homo_co = mkSymCo $ mkCoVarCo kind_ev_id+ rhs' = mkCastTy xi2 homo_co+ ps_rhs' = mkCastTy ps_xi2 homo_co+ ; traceTcS "Hetero equality gives rise to given kind equality"+ (ppr kind_ev_id <+> dcolon <+> ppr kind_pty)+ ; emitWorkNC [kind_ev]+ ; type_ev <- newGivenEvVar loc $+ if isSwapped swapped+ then ( mkTcEqPredLikeEv ev rhs' lhs+ , EvCoercion $+ mkTcCoherenceLeftCo (mkTcCoVarCo evar) homo_co )+ else ( mkTcEqPredLikeEv ev lhs rhs'+ , EvCoercion $+ mkTcCoherenceRightCo (mkTcCoVarCo evar) homo_co )+ -- unswapped: type_ev :: (lhs :: k1) ~ ((rhs |> sym kind_ev_id) :: k1)+ -- swapped : type_ev :: ((rhs |> sym kind_ev_id) :: k1) ~ (lhs :: k1)+ ; canEqTyVarHomo type_ev eq_rel swapped tv1 co1 ps_ty1 rhs' ps_rhs' }++ -- See Note [Equalities with incompatible kinds]+ | otherwise -- Wanted and Derived+ -- NB: all kind equalities are Nominal+ = do { emitNewDerivedEq kind_loc Nominal k1 k2+ -- kind_ev :: (k1 :: *) ~ (k2 :: *)+ ; traceTcS "Hetero equality gives rise to derived kind equality" $+ ppr ev+ ; continueWith (mkIrredCt ev) }++ where+ lhs = mkTyVarTy tv1 `mkCastTy` co1++ Pair _ k1 = coercionKind co1+ k2 = typeKind xi2++ kind_pty = mkHeteroPrimEqPred liftedTypeKind liftedTypeKind k1 k2+ kind_loc = mkKindLoc lhs xi2 loc++ loc = ctev_loc ev++-- guaranteed that typeKind lhs == typeKind rhs+canEqTyVarHomo :: CtEvidence+ -> EqRel -> SwapFlag+ -> TcTyVar -> CoercionN -- lhs: tv1 |> co1+ -> TcType -- pretty lhs+ -> TcType -> TcType -- rhs (might not be flat)+ -> TcS (StopOrContinue Ct)+canEqTyVarHomo ev eq_rel swapped tv1 co1 ps_ty1 ty2 _+ | Just (tv2, _) <- tcGetCastedTyVar_maybe ty2+ , tv1 == tv2+ = canEqReflexive ev eq_rel (mkTyVarTy tv1 `mkCastTy` co1)+ -- we don't need to check co2 because its type must match co1++ | Just (tv2, co2) <- tcGetCastedTyVar_maybe ty2+ , swapOverTyVars tv1 tv2 = do { traceTcS "canEqTyVar" (ppr tv1 $$ ppr tv2 $$ ppr swapped) -- FM_Avoid commented out: see Note [Lazy flattening] in TcFlatten -- let fmode = FE { fe_ev = ev, fe_mode = FM_Avoid tv1' True } -- Flatten the RHS less vigorously, to avoid gratuitous flattening -- True <=> xi2 should not itself be a type-function application ; dflags <- getDynFlags- ; canEqTyVar2 dflags ev eq_rel (flipSwap swapped) tv2 ps_ty1 }+ ; canEqTyVar2 dflags ev eq_rel (flipSwap swapped) tv2 co2 ps_ty1 } -canEqTyVar ev eq_rel swapped tv1 _ _ ps_ty2+canEqTyVarHomo ev eq_rel swapped tv1 co1 _ _ ps_ty2 = do { dflags <- getDynFlags- ; canEqTyVar2 dflags ev eq_rel swapped tv1 ps_ty2 }+ ; canEqTyVar2 dflags ev eq_rel swapped tv1 co1 ps_ty2 } +-- The RHS here is either not a casted tyvar, or it's a tyvar but we want+-- to rewrite the LHS to the RHS (as per swapOverTyVars) canEqTyVar2 :: DynFlags -> CtEvidence -- lhs ~ rhs (or, if swapped, orhs ~ olhs) -> EqRel -> SwapFlag- -> TcTyVar -- lhs, flat- -> TcType -- rhs, flat+ -> TcTyVar -> CoercionN -- lhs = tv |> co, flat+ -> TcType -- rhs -> TcS (StopOrContinue Ct) -- LHS is an inert type variable, -- and RHS is fully rewritten, but with type synonyms -- preserved as much as possible--canEqTyVar2 dflags ev eq_rel swapped tv1 xi2- | Just xi2' <- metaTyVarUpdateOK dflags tv1 xi2 -- No occurs check+canEqTyVar2 dflags ev eq_rel swapped tv1 co1 orhs+ | Just nrhs' <- metaTyVarUpdateOK dflags tv1 nrhs -- No occurs check -- Must do the occurs check even on tyvar/tyvar -- equalities, in case have x ~ (y :: ..x...) -- Trac #12593- = rewriteEqEvidence ev swapped xi1 xi2' co1 co2+ = rewriteEqEvidence ev swapped nlhs nrhs' rewrite_co1 rewrite_co2 `andWhenContinue` \ new_ev ->- homogeniseRhsKind new_ev eq_rel xi1 xi2' $ \new_new_ev xi2'' ->- CTyEqCan { cc_ev = new_new_ev, cc_tyvar = tv1- , cc_rhs = xi2'', cc_eq_rel = eq_rel }+ continueWith (CTyEqCan { cc_ev = new_ev, cc_tyvar = tv1+ , cc_rhs = nrhs', cc_eq_rel = eq_rel }) | otherwise -- For some reason (occurs check, or forall) we can't unify -- We must not use it for further rewriting!- = do { traceTcS "canEqTyVar2 can't unify" (ppr tv1 $$ ppr xi2)- ; rewriteEqEvidence ev swapped xi1 xi2 co1 co2+ = do { traceTcS "canEqTyVar2 can't unify" (ppr tv1 $$ ppr nrhs)+ ; rewriteEqEvidence ev swapped nlhs nrhs rewrite_co1 rewrite_co2 `andWhenContinue` \ new_ev ->- if isInsolubleOccursCheck eq_rel tv1 xi2- then do { emitInsoluble (mkNonCanonical new_ev)+ if isInsolubleOccursCheck eq_rel tv1 nrhs+ then continueWith (mkInsolubleCt new_ev) -- If we have a ~ [a], it is not canonical, and in particular -- we don't want to rewrite existing inerts with it, otherwise -- we'd risk divergence in the constraint solver- ; stopWith new_ev "Occurs check" } + else continueWith (mkIrredCt new_ev) } -- A representational equality with an occurs-check problem isn't -- insoluble! For example: -- a ~R b a -- We might learn that b is the newtype Id. -- But, the occurs-check certainly prevents the equality from being -- canonical, and we might loop if we were to use it in rewriting.- else do { traceTcS "Possibly-soluble occurs check"- (ppr xi1 $$ ppr xi2)- ; continueWith (CIrredEvCan { cc_ev = new_ev }) } } where role = eqRelRole eq_rel- xi1 = mkTyVarTy tv1- co1 = mkTcReflCo role xi1- co2 = mkTcReflCo role xi2 + nlhs = mkTyVarTy tv1+ nrhs = orhs `mkCastTy` mkTcSymCo co1++ -- rewrite_co1 :: tv1 ~ (tv1 |> co1)+ -- rewrite_co2 :: (rhs |> sym co1) ~ rhs+ rewrite_co1 = mkTcReflCo role nlhs `mkTcCoherenceRightCo` co1+ rewrite_co2 = mkTcReflCo role orhs `mkTcCoherenceLeftCo` mkTcSymCo co1+ -- | Solve a reflexive equality constraint canEqReflexive :: CtEvidence -- ty ~ ty -> EqRel@@ -1476,75 +1593,6 @@ mkTcReflCo (eqRelRole eq_rel) ty) ; stopWith ev "Solved by reflexivity" } --- See Note [Equalities with incompatible kinds]-homogeniseRhsKind :: CtEvidence -- ^ the evidence to homogenise- -> EqRel- -> TcType -- ^ original LHS- -> Xi -- ^ original RHS- -> (CtEvidence -> Xi -> Ct)- -- ^ how to build the homogenised constraint;- -- the 'Xi' is the new RHS- -> TcS (StopOrContinue Ct)-homogeniseRhsKind ev eq_rel lhs rhs build_ct- | k1 `tcEqType` k2- = continueWith (build_ct ev rhs)-- | CtGiven { ctev_evar = evar } <- ev- -- tm :: (lhs :: k1) ~ (rhs :: k2)- = do { kind_ev_id <- newBoundEvVarId kind_pty- (EvCoercion $- mkTcKindCo $ mkTcCoVarCo evar)- -- kind_ev_id :: (k1 :: *) ~# (k2 :: *)- ; let kind_ev = CtGiven { ctev_pred = kind_pty- , ctev_evar = kind_ev_id- , ctev_loc = kind_loc }- homo_co = mkSymCo $ mkCoVarCo kind_ev_id- rhs' = mkCastTy rhs homo_co- ; traceTcS "Hetero equality gives rise to given kind equality"- (ppr kind_ev_id <+> dcolon <+> ppr kind_pty)- ; emitWorkNC [kind_ev]- ; type_ev <- newGivenEvVar loc- ( mkTcEqPredLikeEv ev lhs rhs'- , EvCoercion $- mkTcCoherenceRightCo (mkTcCoVarCo evar) homo_co )- -- type_ev :: (lhs :: k1) ~ ((rhs |> sym kind_ev_id) :: k1)- ; continueWith (build_ct type_ev rhs') }-- | otherwise -- Wanted and Derived. See Note [No derived kind equalities]- -- evar :: (lhs :: k1) ~ (rhs :: k2)- = do { kind_co <- emitNewWantedEq kind_loc Nominal k1 k2- -- kind_ev :: (k1 :: *) ~ (k2 :: *)- ; traceTcS "Hetero equality gives rise to wanted kind equality" $- ppr (kind_co)- ; let homo_co = mkSymCo kind_co- -- homo_co :: k2 ~ k1- rhs' = mkCastTy rhs homo_co- ; case ev of- CtGiven {} -> panic "homogeniseRhsKind"- CtDerived {} -> continueWith (build_ct (ev { ctev_pred = homo_pred })- rhs')- where homo_pred = mkTcEqPredLikeEv ev lhs rhs'- CtWanted { ctev_dest = dest } -> do- { (type_ev, hole_co) <- newWantedEq loc role lhs rhs'- -- type_ev :: (lhs :: k1) ~ (rhs |> sym kind_co :: k1)- ; setWantedEq dest- (hole_co `mkTransCo`- (mkReflCo role rhs- `mkCoherenceLeftCo` homo_co))-- -- dest := hole ; <rhs> |> homo_co :: (lhs :: k1) ~ (rhs :: k2)- ; continueWith (build_ct type_ev rhs') }}-- where- k1 = typeKind lhs- k2 = typeKind rhs-- kind_pty = mkHeteroPrimEqPred liftedTypeKind liftedTypeKind k1 k2- kind_loc = mkKindLoc lhs rhs loc-- loc = ctev_loc ev- role = eqRelRole eq_rel- {- Note [Canonical orientation for tyvar/tyvar equality constraints] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1575,7 +1623,7 @@ Note [Avoid unnecessary swaps] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If we swap without actually improving matters, we can get an infnite loop.+If we swap without actually improving matters, we can get an infinite loop. Consider work item: a ~ b inert item: b ~ c@@ -1592,7 +1640,7 @@ then we flatten to [G] Num fsk [G] F [a] ~ fsk-where fsk is a flatten-skolem (FlatSkol). Suppose we have+where fsk is a flatten-skolem (FlatSkolTv). Suppose we have type instance F [a] = a then we'll reduce the second constraint to [G] a ~ fsk@@ -1606,22 +1654,72 @@ Note [Equalities with incompatible kinds] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-canEqLeaf is about to make a CTyEqCan or CFunEqCan; but both have the-invariant that LHS and RHS satisfy the kind invariants for CTyEqCan,-CFunEqCan. What if we try to unify two things with incompatible-kinds?+What do we do when we have an equality -eg a ~ b where a::*, b::*->*-or a ~ b where a::*, b::k, k is a kind variable+ (tv :: k1) ~ (rhs :: k2) -The CTyEqCan compatKind invariant is important. If we make a CTyEqCan-for a~b, then we might well *substitute* 'b' for 'a', and that might make-a well-kinded type ill-kinded; and that is bad (eg typeKind can crash, see-Trac #7696).+where k1 and k2 differ? This Note explores this treacherous area. -So instead for these ill-kinded equalities we homogenise the RHS of the-equality, emitting new constraints as necessary.+First off, the question above is slightly the wrong question. Flattening+a tyvar will flatten its kind (Note [Flattening] in TcFlatten); flattening+the kind might introduce a cast. So we might have a casted tyvar on the+left. We thus revise our test case to + (tv |> co :: k1) ~ (rhs :: k2)++We must proceed differently here depending on whether we have a Wanted+or a Given. Consider this:++ [W] w :: (alpha :: k) ~ (Int :: Type)++where k is a skolem. One possible way forward is this:++ [W] co :: k ~ Type+ [W] w :: (alpha :: k) ~ (Int |> sym co :: k)++The next step will be to unify++ alpha := Int |> sym co++Now, consider what error we'll report if we can't solve the "co"+wanted. Its CtOrigin is the w wanted... which now reads (after zonking)+Int ~ Int. The user thus sees that GHC can't solve Int ~ Int, which+is embarrassing. See #11198 for more tales of destruction.++The reason for this odd behavior is much the same as+Note [Wanteds do not rewrite Wanteds] in TcRnTypes: note that the+new `co` is a Wanted.++ The solution is then not to use `co` to "rewrite" -- that is, cast+ -- `w`, but instead to keep `w` heterogeneous and+ irreducible. Given that we're not using `co`, there is no reason to+ collect evidence for it, so `co` is born a Derived, with a CtOrigin+ of KindEqOrigin.++When the Derived is solved (by unification), the original wanted (`w`)+will get kicked out.++Note that, if we had [G] co1 :: k ~ Type available, then none of this code would+trigger, because flattening would have rewritten k to Type. That is,+`w` would look like [W] (alpha |> co1 :: Type) ~ (Int :: Type), and the tyvar+case will trigger, correctly rewriting alpha to (Int |> sym co1).++Successive canonicalizations of the same Wanted may produce+duplicate Deriveds. Similar duplications can happen with fundeps, and there+seems to be no easy way to avoid. I expect this case to be rare.++For Givens, this problem doesn't bite, so a heterogeneous Given gives+rise to a Given kind equality. No Deriveds here. We thus homogenise+the Given (see the "homo_co" in the Given case in canEqTyVar) and+carry on with a homogeneous equality constraint.++Separately, I (Richard E) spent some time pondering what to do in the case+that we have [W] (tv |> co1 :: k1) ~ (tv |> co2 :: k2) where k1 and k2+differ. Note that the tv is the same. (This case is handled as the first+case in canEqTyVarHomo.) At one point, I thought we could solve this limited+form of heterogeneous Wanted, but I then reconsidered and now treat this case+just like any other heterogeneous Wanted.+ Note [Type synonyms and canonicalization] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We treat type synonym applications as xi types, that is, they do not@@ -1758,7 +1856,7 @@ | isTcReflCo co -- See Note [Rewriting with Refl] = continueWith (old_ev { ctev_pred = new_pred }) -rewriteEvidence ev@(CtGiven { ctev_evar = old_evar , ctev_loc = loc }) new_pred co+rewriteEvidence ev@(CtGiven { ctev_evar = old_evar, ctev_loc = loc }) new_pred co = do { new_ev <- newGivenEvVar loc (new_pred, new_tm) ; continueWith new_ev } where
typecheck/TcClassDcl.hs view
@@ -7,17 +7,21 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module TcClassDcl ( tcClassSigs, tcClassDecl2, findMethodBind, instantiateMethod, tcClassMinimalDef, HsSigFun, mkHsSigFun, tcMkDeclCtxt, tcAddDeclCtxt, badMethodErr,+ instDeclCtxt1, instDeclCtxt2, instDeclCtxt3, tcATDefault ) where #include "HsVersions.h" +import GhcPrelude+ import HsSyn import TcEnv import TcSigs@@ -101,8 +105,8 @@ text "Illegal default method(s) in class definition of" <+> ppr n <+> text "in hsig file" tcClassSigs :: Name -- Name of the class- -> [LSig Name]- -> LHsBinds Name+ -> [LSig GhcRn]+ -> LHsBinds GhcRn -> TcM [TcMethInfo] -- Exactly one for each method tcClassSigs clas sigs def_methods = do { traceTc "tcClassSigs 1" (ppr clas)@@ -137,10 +141,10 @@ where vanilla_sigs = [L loc (nm,ty) | L loc (ClassOpSig False nm ty) <- sigs] gen_sigs = [L loc (nm,ty) | L loc (ClassOpSig True nm ty) <- sigs]- dm_bind_names :: [Name] -- These ones have a value binding in the class decl+ dm_bind_names :: [Name] -- These ones have a value binding in the class decl dm_bind_names = [op | L _ (FunBind {fun_id = L _ op}) <- bagToList def_methods] - tc_sig :: NameEnv (SrcSpan, Type) -> ([Located Name], LHsSigType Name)+ tc_sig :: NameEnv (SrcSpan, Type) -> ([Located Name], LHsSigType GhcRn) -> TcM [TcMethInfo] tc_sig gen_dm_env (op_names, op_hs_ty) = do { traceTc "ClsSig 1" (ppr op_names)@@ -164,8 +168,8 @@ ************************************************************************ -} -tcClassDecl2 :: LTyClDecl Name -- The class declaration- -> TcM (LHsBinds Id)+tcClassDecl2 :: LTyClDecl GhcRn -- The class declaration+ -> TcM (LHsBinds GhcTcId) tcClassDecl2 (L _ (ClassDecl {tcdLName = class_name, tcdSigs = sigs, tcdMeths = default_binds}))@@ -197,9 +201,9 @@ tcClassDecl2 d = pprPanic "tcClassDecl2" (ppr d) -tcDefMeth :: Class -> [TyVar] -> EvVar -> LHsBinds Name+tcDefMeth :: Class -> [TyVar] -> EvVar -> LHsBinds GhcRn -> HsSigFun -> TcPragEnv -> ClassOpItem- -> TcM (LHsBinds TcId)+ -> TcM (LHsBinds GhcTcId) -- Generate code for default methods -- This is incompatible with Hugs, which expects a polymorphic -- default method for every class op, regardless of whether or not@@ -277,14 +281,15 @@ (L bind_loc lm_bind) ; let export = ABE { abe_poly = global_dm_id- , abe_mono = local_dm_id- , abe_wrap = idHsWrapper- , abe_prags = IsDefaultMethod }+ , abe_mono = local_dm_id+ , abe_wrap = idHsWrapper+ , abe_prags = IsDefaultMethod } full_bind = AbsBinds { abs_tvs = tyvars , abs_ev_vars = [this_dict] , abs_exports = [export] , abs_ev_binds = [ev_binds]- , abs_binds = tc_bind }+ , abs_binds = tc_bind+ , abs_sig = True } ; return (unitBag (L bind_loc full_bind)) } @@ -295,7 +300,7 @@ -- they are all for meth_id ----------------tcClassMinimalDef :: Name -> [LSig Name] -> [TcMethInfo] -> TcM ClassMinimalDef+tcClassMinimalDef :: Name -> [LSig GhcRn] -> [TcMethInfo] -> TcM ClassMinimalDef tcClassMinimalDef _clas sigs op_info = case findMinimalDef sigs of Nothing -> return defMindef@@ -317,7 +322,7 @@ defMindef = mkAnd [ noLoc (mkVar name) | (name, _, Nothing) <- op_info ] -instantiateMethod :: Class -> Id -> [TcType] -> TcType+instantiateMethod :: Class -> TcId -> [TcType] -> TcType -- Take a class operation, say -- op :: forall ab. C a => forall c. Ix c => (b,c) -> a -- Instantiate it at [ty1,ty2]@@ -338,22 +343,22 @@ ----------------------------type HsSigFun = Name -> Maybe (LHsSigType Name)+type HsSigFun = Name -> Maybe (LHsSigType GhcRn) -mkHsSigFun :: [LSig Name] -> HsSigFun+mkHsSigFun :: [LSig GhcRn] -> HsSigFun mkHsSigFun sigs = lookupNameEnv env where env = mkHsSigEnv get_classop_sig sigs - get_classop_sig :: LSig Name -> Maybe ([Located Name], LHsSigType Name)+ get_classop_sig :: LSig GhcRn -> Maybe ([Located Name], LHsSigType GhcRn) get_classop_sig (L _ (ClassOpSig _ ns hs_ty)) = Just (ns, hs_ty) get_classop_sig _ = Nothing --------------------------- findMethodBind :: Name -- Selector- -> LHsBinds Name -- A group of bindings+ -> LHsBinds GhcRn -- A group of bindings -> TcPragEnv- -> Maybe (LHsBind Name, SrcSpan, [LSig Name])+ -> Maybe (LHsBind GhcRn, SrcSpan, [LSig GhcRn]) -- Returns the binding, the binding -- site of the method binder, and any inline or -- specialisation pragmas@@ -368,10 +373,10 @@ f _other = Nothing ----------------------------findMinimalDef :: [LSig Name] -> Maybe ClassMinimalDef+findMinimalDef :: [LSig GhcRn] -> Maybe ClassMinimalDef findMinimalDef = firstJusts . map toMinimalDef where- toMinimalDef :: LSig Name -> Maybe ClassMinimalDef+ toMinimalDef :: LSig GhcRn -> Maybe ClassMinimalDef toMinimalDef (L _ (MinimalSig _ (L _ bf))) = Just (fmap unLoc bf) toMinimalDef _ = Nothing @@ -410,11 +415,11 @@ ************************************************************************ -} -tcMkDeclCtxt :: TyClDecl Name -> SDoc+tcMkDeclCtxt :: TyClDecl GhcRn -> SDoc tcMkDeclCtxt decl = hsep [text "In the", pprTyClDeclFlavour decl, text "declaration for", quotes (ppr (tcdName decl))] -tcAddDeclCtxt :: TyClDecl Name -> TcM a -> TcM a+tcAddDeclCtxt :: TyClDecl GhcRn -> TcM a -> TcM a tcAddDeclCtxt decl thing_inside = addErrCtxt (tcMkDeclCtxt decl) thing_inside @@ -447,7 +452,7 @@ where ppr_inst_ty (_,inst) = ppr (simpleInstInfoTy inst) -}-badDmPrag :: Id -> Sig Name -> TcM ()+badDmPrag :: TcId -> Sig GhcRn -> TcM () badDmPrag sel_id prag = addErrTc (text "The" <+> hsSigDoc prag <+> ptext (sLit "for default method") <+> quotes (ppr sel_id)@@ -459,9 +464,25 @@ , nest 2 (pprBooleanFormulaNice mindef) , text "but there is no default implementation." ] -tcATDefault :: Bool -- If a warning should be emitted when a default instance- -- definition is not provided by the user- -> SrcSpan+instDeclCtxt1 :: LHsSigType GhcRn -> SDoc+instDeclCtxt1 hs_inst_ty+ = inst_decl_ctxt (ppr (getLHsInstDeclHead hs_inst_ty))++instDeclCtxt2 :: Type -> SDoc+instDeclCtxt2 dfun_ty+ = instDeclCtxt3 cls tys+ where+ (_,_,cls,tys) = tcSplitDFunTy dfun_ty++instDeclCtxt3 :: Class -> [Type] -> SDoc+instDeclCtxt3 cls cls_tys+ = inst_decl_ctxt (ppr (mkClassPred cls cls_tys))++inst_decl_ctxt :: SDoc -> SDoc+inst_decl_ctxt doc = hang (text "In the instance declaration for")+ 2 (quotes doc)++tcATDefault :: SrcSpan -> TCvSubst -> NameSet -> ClassATItem@@ -469,7 +490,7 @@ -- ^ Construct default instances for any associated types that -- aren't given a user definition -- Returns [] or singleton-tcATDefault emit_warn loc inst_subst defined_ats (ATI fam_tc defs)+tcATDefault loc inst_subst defined_ats (ATI fam_tc defs) -- User supplied instances ==> everything is OK | tyConName fam_tc `elemNameSet` defined_ats = return []@@ -501,7 +522,7 @@ -- No defaults ==> generate a warning | otherwise -- defs = Nothing- = do { when emit_warn $ warnMissingAT (tyConName fam_tc)+ = do { warnMissingAT (tyConName fam_tc) ; return [] } where subst_tv subst tc_tv@@ -520,5 +541,5 @@ -- Warn only if -Wmissing-methods AND not a signature ; warnTc (Reason Opt_WarnMissingMethods) (warn && hsc_src /= HsigFile) (text "No explicit" <+> text "associated type"- <+> text "or default declaration for "+ <+> text "or default declaration for" <+> quotes (ppr name)) }
typecheck/TcDefaults.hs view
@@ -4,11 +4,13 @@ \section[TcDefaults]{Typechecking \tr{default} declarations} -}+{-# LANGUAGE TypeFamilies #-} module TcDefaults ( tcDefaults ) where +import GhcPrelude+ import HsSyn-import Name import Class import TcRnMonad import TcEnv@@ -23,7 +25,7 @@ import FastString import qualified GHC.LanguageExtensions as LangExt -tcDefaults :: [LDefaultDecl Name]+tcDefaults :: [LDefaultDecl GhcRn] -> TcM (Maybe [Type]) -- Defaulting types to heave -- into Tc monad for later use -- in Disambig.@@ -66,7 +68,7 @@ failWithTc (dupDefaultDeclErr decls) -tc_default_ty :: [Class] -> LHsType Name -> TcM Type+tc_default_ty :: [Class] -> LHsType GhcRn -> TcM Type tc_default_ty deflt_clss hs_ty = do { (ty, _kind) <- solveEqualities $ tcLHsType hs_ty@@ -90,7 +92,7 @@ defaultDeclCtxt :: SDoc defaultDeclCtxt = text "When checking the types in a default declaration" -dupDefaultDeclErr :: [Located (DefaultDecl Name)] -> SDoc+dupDefaultDeclErr :: [Located (DefaultDecl GhcRn)] -> SDoc dupDefaultDeclErr (L _ (DefaultDecl _) : dup_things) = hang (text "Multiple default declarations") 2 (vcat (map pp dup_things))
typecheck/TcDeriv.hs view
@@ -7,11 +7,14 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module TcDeriv ( tcDeriving, DerivInfo(..), mkDerivInfos ) where #include "HsVersions.h" +import GhcPrelude+ import HsSyn import DynFlags @@ -20,18 +23,18 @@ import TcDerivInfer import TcDerivUtils import TcValidity( allDistinctTyVars )-import TcClassDcl( tcATDefault, tcMkDeclCtxt )+import TcClassDcl( instDeclCtxt3, tcATDefault, tcMkDeclCtxt ) import TcEnv import TcGenDeriv -- Deriv stuff import InstEnv import Inst import FamInstEnv import TcHsType-import TcMType import RnNames( extendGlobalRdrEnvRn ) import RnBinds import RnEnv+import RnUtils ( bindLocalNamesFV ) import RnSource ( addTcgDUs ) import Avail @@ -61,6 +64,8 @@ import qualified GHC.LanguageExtensions as LangExt import Control.Monad+import Control.Monad.Trans.Class+import Control.Monad.Trans.Reader import Data.List {-@@ -189,12 +194,12 @@ data DerivInfo = DerivInfo { di_rep_tc :: TyCon -- ^ The data tycon for normal datatypes, -- or the *representation* tycon for data families- , di_clauses :: [LHsDerivingClause Name]+ , di_clauses :: [LHsDerivingClause GhcRn] , di_ctxt :: SDoc -- ^ error context } -- | Extract `deriving` clauses of proper data type (skips data families)-mkDerivInfos :: [LTyClDecl Name] -> TcM [DerivInfo]+mkDerivInfos :: [LTyClDecl GhcRn] -> TcM [DerivInfo] mkDerivInfos decls = concatMapM (mk_deriv . unLoc) decls where @@ -216,8 +221,8 @@ -} tcDeriving :: [DerivInfo] -- All `deriving` clauses- -> [LDerivDecl Name] -- All stand-alone deriving declarations- -> TcM (TcGblEnv, Bag (InstInfo Name), HsValBinds Name)+ -> [LDerivDecl GhcRn] -- All stand-alone deriving declarations+ -> TcM (TcGblEnv, Bag (InstInfo GhcRn), HsValBinds GhcRn) tcDeriving deriv_infos deriv_decls = recoverM (do { g <- getGblEnv ; return (g, emptyBag, emptyValBindsOut)}) $@@ -235,7 +240,7 @@ ; dflags <- getDynFlags - ; let (_, deriv_stuff, maybe_fvs) = unzip3 (insts1 ++ insts2)+ ; let (_, deriv_stuff, fvs) = unzip3 (insts1 ++ insts2) ; loc <- getSrcSpanM ; let (binds, famInsts) = genAuxBinds dflags loc (unionManyBags deriv_stuff)@@ -274,10 +279,10 @@ ; gbl_env <- tcExtendLocalInstEnv (map iSpec (bagToList inst_info)) getGblEnv- ; let all_dus = rn_dus `plusDU` usesOnly (NameSet.mkFVs $ catMaybes maybe_fvs)+ ; let all_dus = rn_dus `plusDU` usesOnly (NameSet.mkFVs $ concat fvs) ; return (addTcgDUs gbl_env all_dus, inst_info, rn_binds) } } where- ddump_deriving :: Bag (InstInfo Name) -> HsValBinds Name+ ddump_deriving :: Bag (InstInfo GhcRn) -> HsValBinds GhcRn -> Bag FamInst -- ^ Rep type family instances -> SDoc ddump_deriving inst_infos extra_binds repFamInsts@@ -291,8 +296,8 @@ -- Apply the suspended computations given by genInst calls. -- See Note [Staging of tcDeriving]- apply_inst_infos :: [ThetaType -> TcM (InstInfo RdrName)]- -> [DerivSpec ThetaType] -> TcM [InstInfo RdrName]+ apply_inst_infos :: [ThetaType -> TcM (InstInfo GhcPs)]+ -> [DerivSpec ThetaType] -> TcM [InstInfo GhcPs] apply_inst_infos = zipWithM (\f ds -> f (ds_theta ds)) -- Prints the representable type family instance@@ -303,9 +308,9 @@ where rhs = famInstRHS fi renameDeriv :: Bool- -> [InstInfo RdrName]- -> Bag (LHsBind RdrName, LSig RdrName)- -> TcM (Bag (InstInfo Name), HsValBinds Name, DefUses)+ -> [InstInfo GhcPs]+ -> Bag (LHsBind GhcPs, LSig GhcPs)+ -> TcM (Bag (InstInfo GhcRn), HsValBinds GhcRn, DefUses) renameDeriv is_boot inst_infos bagBinds | is_boot -- If we are compiling a hs-boot file, don't generate any derived bindings -- The inst-info bindings will all be empty, but it's easier to@@ -342,7 +347,7 @@ dus_aux `plusDU` usesOnly (plusFVs fvs_insts)) } } where- rn_inst_info :: InstInfo RdrName -> TcM (InstInfo Name, FreeVars)+ rn_inst_info :: InstInfo GhcPs -> TcM (InstInfo GhcRn, FreeVars) rn_inst_info inst_info@(InstInfo { iSpec = inst , iBinds = InstBindings@@ -378,7 +383,7 @@ ...etc... So we want to signal a user of the data constructor 'MkP'.-This is the reason behind the (Maybe Name) part of the return type+This is the reason behind the [Name] part of the return type of genInst. Note [Staging of tcDeriving]@@ -491,12 +496,24 @@ makeDerivSpecs :: Bool -> [DerivInfo]- -> [LDerivDecl Name]+ -> [LDerivDecl GhcRn] -> TcM [EarlyDerivSpec] makeDerivSpecs is_boot deriv_infos deriv_decls- = do { eqns1 <- concatMapM (recoverM (return []) . deriveDerivInfo) deriv_infos- ; eqns2 <- concatMapM (recoverM (return []) . deriveStandalone) deriv_decls- ; let eqns = eqns1 ++ eqns2+ = do { -- We carefully set up uses of recoverM to minimize error message+ -- cascades. See Note [Flattening deriving clauses].+ ; eqns1 <- sequenceA+ [ recoverM (pure Nothing)+ (deriveClause rep_tc (fmap unLoc dcs)+ pred err_ctxt)+ | DerivInfo { di_rep_tc = rep_tc, di_clauses = clauses+ , di_ctxt = err_ctxt } <- deriv_infos+ , L _ (HsDerivingClause { deriv_clause_strategy = dcs+ , deriv_clause_tys = L _ preds })+ <- clauses+ , pred <- preds+ ]+ ; eqns2 <- mapM (recoverM (pure Nothing) . deriveStandalone) deriv_decls+ ; let eqns = catMaybes (eqns1 ++ eqns2) ; if is_boot then -- No 'deriving' at all in hs-boot files do { unless (null eqns) (add_deriv_err (head eqns))@@ -508,13 +525,69 @@ addErr (hang (text "Deriving not permitted in hs-boot file") 2 (text "Use an instance declaration instead")) +{-+Note [Flattening deriving clauses]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider what happens if you run this program (from Trac #10684) without+DeriveGeneric enabled:++ data A = A deriving (Show, Generic)+ data B = B A deriving (Show)++Naturally, you'd expect GHC to give an error to the effect of:++ Can't make a derived instance of `Generic A':+ You need -XDeriveGeneric to derive an instance for this class++And *only* that error, since the other two derived Show instances appear to be+independent of this derived Generic instance. Yet GHC also used to give this+additional error on the program above:++ No instance for (Show A)+ arising from the 'deriving' clause of a data type declaration+ When deriving the instance for (Show B)++This was happening because when GHC encountered any error within a single+data type's set of deriving clauses, it would call recoverM and move on+to the next data type's deriving clauses. One unfortunate consequence of+this design is that if A's derived Generic instance failed, so its derived+Show instance would be skipped entirely, leading to the "No instance for+(Show A)" error cascade.++The solution to this problem is to "flatten" the set of classes that are+derived for a particular data type via deriving clauses. That is, if+you have:++ newtype C = C D+ deriving (E, F, G)+ deriving anyclass (H, I, J)+ deriving newtype (K, L, M)++Then instead of processing instances E through M under the scope of a single+recoverM, we flatten these deriving clauses into the list:++ [ E (Nothing)+ , F (Nothing)+ , G (Nothing)+ , H (Just anyclass)+ , I (Just anyclass)+ , J (Just anyclass)+ , K (Just newtype)+ , L (Just newtype)+ , M (Just newtype) ]++And then process each class individually, under its own recoverM scope. That+way, failure to derive one class doesn't cancel out other classes in the+same set of clause-derived classes.+-}+ --------------------------------------------------------------------- | Process a `deriving` clause-deriveDerivInfo :: DerivInfo -> TcM [EarlyDerivSpec]-deriveDerivInfo (DerivInfo { di_rep_tc = rep_tc, di_clauses = clauses- , di_ctxt = err_ctxt })+-- | Process a single class in a `deriving` clause.+deriveClause :: TyCon -> Maybe DerivStrategy -> LHsSigType GhcRn -> SDoc+ -> TcM (Maybe EarlyDerivSpec)+deriveClause rep_tc mb_strat pred err_ctxt = addErrCtxt err_ctxt $- concatMapM (deriveForClause . unLoc) clauses+ deriveTyData tvs tc tys mb_strat pred where tvs = tyConTyVars rep_tc (tc, tys) = case tyConFamInstSig_maybe rep_tc of@@ -525,16 +598,14 @@ _ -> (rep_tc, mkTyVarTys tvs) -- datatype - deriveForClause :: HsDerivingClause Name -> TcM [EarlyDerivSpec]- deriveForClause (HsDerivingClause { deriv_clause_strategy = dcs- , deriv_clause_tys = L _ preds })- = concatMapM (deriveTyData tvs tc tys (fmap unLoc dcs)) preds- -------------------------------------------------------------------deriveStandalone :: LDerivDecl Name -> TcM [EarlyDerivSpec]--- Standalone deriving declarations+deriveStandalone :: LDerivDecl GhcRn -> TcM (Maybe EarlyDerivSpec)+-- Process a single standalone deriving declaration -- e.g. deriving instance Show a => Show (T a) -- Rather like tcLocalInstDecl+--+-- This returns a Maybe because the user might try to derive Typeable, which is+-- a no-op nowadays. deriveStandalone (L loc (DerivDecl deriv_ty deriv_strat' overlap_mode)) = setSrcSpan loc $ addErrCtxt (standaloneCtxt deriv_ty) $@@ -565,7 +636,7 @@ Just (tc, tc_args) | className cls == typeableClassName -> do warnUselessTypeable- return []+ return Nothing | isUnboxedTupleTyCon tc -> bale_out $ unboxedTyConErr "tuple"@@ -577,7 +648,7 @@ -> do { spec <- mkEqnHelp (fmap unLoc overlap_mode) tvs cls cls_tys tc tc_args (Just theta) deriv_strat- ; return [spec] }+ ; return $ Just spec } _ -> -- Complain about functions, primitive types, etc, bale_out $@@ -595,10 +666,13 @@ deriveTyData :: [TyVar] -> TyCon -> [Type] -- LHS of data or data instance -- Can be a data instance, hence [Type] args -> Maybe DerivStrategy -- The optional deriving strategy- -> LHsSigType Name -- The deriving predicate- -> TcM [EarlyDerivSpec]+ -> LHsSigType GhcRn -- The deriving predicate+ -> TcM (Maybe EarlyDerivSpec) -- The deriving clause of a data or newtype declaration -- I.e. not standalone deriving+--+-- This returns a Maybe because the user might try to derive Typeable, which is+-- a no-op nowadays. deriveTyData tvs tc tc_args deriv_strat deriv_pred = setSrcSpan (getLoc (hsSigType deriv_pred)) $ -- Use loc of the 'deriving' item do { (deriv_tvs, cls, cls_tys, cls_arg_kinds)@@ -612,12 +686,12 @@ -- Typeable is special, because Typeable :: forall k. k -> Constraint -- so the argument kind 'k' is not decomposable by splitKindFunTys -- as is the case for all other derivable type classes- ; when (length cls_arg_kinds /= 1) $+ ; when (cls_arg_kinds `lengthIsNot` 1) $ failWithTc (nonUnaryErr deriv_pred) ; let [cls_arg_kind] = cls_arg_kinds ; if className cls == typeableClassName then do warnUselessTypeable- return []+ return Nothing else do { -- Given data T a b c = ... deriving( C d ),@@ -689,7 +763,7 @@ cls final_cls_tys tc final_tc_args Nothing deriv_strat ; traceTc "derivTyData" (ppr spec)- ; return [spec] } }+ ; return $ Just spec } } {-@@ -793,7 +867,7 @@ newtype Fun a b = Fun (a -> b) deriving (Cat k) -Even though we requested an derived instance of the form (Cat k Fun), the+Even though we requested a derived instance of the form (Cat k Fun), the kind unification will actually generate (Cat * Fun) (i.e., the same thing as if the user wrote deriving (Cat *)). @@ -882,14 +956,24 @@ -- If it's still a data family, the lookup failed; i.e no instance exists ; when (isDataFamilyTyCon rep_tc) (bale_out (text "No family instance for" <+> quotes (pprTypeApp tycon tc_args)))+ ; is_boot <- tcIsHsBootOrSig+ ; when is_boot $+ bale_out (text "Cannot derive instances in hs-boot files"+ $+$ text "Write an instance declaration instead") - ; dflags <- getDynFlags- ; if isDataTyCon rep_tc then- mkDataTypeEqn dflags overlap_mode tvs cls cls_tys- tycon tc_args rep_tc rep_tc_args mtheta deriv_strat- else- mkNewTypeEqn dflags overlap_mode tvs cls cls_tys- tycon tc_args rep_tc rep_tc_args mtheta deriv_strat }+ ; let deriv_env = DerivEnv+ { denv_overlap_mode = overlap_mode+ , denv_tvs = tvs+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_tc = tycon+ , denv_tc_args = tc_args+ , denv_rep_tc = rep_tc+ , denv_rep_tc_args = rep_tc_args+ , denv_mtheta = mtheta+ , denv_strat = deriv_strat }+ ; flip runReaderT deriv_env $+ if isDataTyCon rep_tc then mkDataTypeEqn else mkNewTypeEqn } where bale_out msg = failWithTc (derivingThingErr False cls cls_tys (mkTyConApp tycon tc_args) deriv_strat msg)@@ -960,59 +1044,42 @@ ************************************************************************ -} -mkDataTypeEqn :: DynFlags- -> Maybe OverlapMode- -> [TyVar] -- Universally quantified type variables in the instance- -> Class -- Class for which we need to derive an instance- -> [Type] -- Other parameters to the class except the last- -> TyCon -- Type constructor for which the instance is requested- -- (last parameter to the type class)- -> [Type] -- Parameters to the type constructor- -> TyCon -- rep of the above (for type families)- -> [Type] -- rep of the above- -> DerivContext -- Context of the instance, for standalone deriving- -> Maybe DerivStrategy -- 'Just' if user requests a particular- -- deriving strategy.- -- Otherwise, 'Nothing'.- -> TcRn EarlyDerivSpec -- Return 'Nothing' if error--mkDataTypeEqn dflags overlap_mode tvs cls cls_tys- tycon tc_args rep_tc rep_tc_args mtheta deriv_strat- = case deriv_strat of- Just StockStrategy -> mk_eqn_stock dflags mtheta cls cls_tys rep_tc- go_for_it bale_out- Just AnyclassStrategy -> mk_eqn_anyclass dflags go_for_it bale_out- -- GeneralizedNewtypeDeriving makes no sense for non-newtypes- Just NewtypeStrategy -> bale_out gndNonNewtypeErr- -- Lacking a user-requested deriving strategy, we will try to pick- -- between the stock or anyclass strategies- Nothing -> mk_eqn_no_mechanism dflags tycon mtheta cls cls_tys rep_tc- go_for_it bale_out- where- go_for_it = mk_data_eqn overlap_mode tvs cls cls_tys tycon tc_args- rep_tc rep_tc_args mtheta (isJust deriv_strat)- bale_out msg = failWithTc (derivingThingErr False cls cls_tys- (mkTyConApp tycon tc_args) deriv_strat msg)+mkDataTypeEqn :: DerivM EarlyDerivSpec+mkDataTypeEqn+ = do mb_strat <- asks denv_strat+ let bale_out msg = do err <- derivingThingErrM False msg+ lift $ failWithTc err+ case mb_strat of+ Just StockStrategy -> mk_eqn_stock mk_data_eqn bale_out+ Just AnyclassStrategy -> mk_eqn_anyclass mk_data_eqn bale_out+ -- GeneralizedNewtypeDeriving makes no sense for non-newtypes+ Just NewtypeStrategy -> bale_out gndNonNewtypeErr+ -- Lacking a user-requested deriving strategy, we will try to pick+ -- between the stock or anyclass strategies+ Nothing -> mk_eqn_no_mechanism mk_data_eqn bale_out -mk_data_eqn :: Maybe OverlapMode -> [TyVar] -> Class -> [Type]- -> TyCon -> [TcType] -> TyCon -> [TcType] -> DerivContext- -> Bool -- True if an explicit deriving strategy keyword was- -- provided- -> DerivSpecMechanism -- How GHC should proceed attempting to+mk_data_eqn :: DerivSpecMechanism -- How GHC should proceed attempting to -- derive this instance, determined in -- mkDataTypeEqn/mkNewTypeEqn- -> TcM EarlyDerivSpec-mk_data_eqn overlap_mode tvs cls cls_tys tycon tc_args rep_tc rep_tc_args- mtheta strat_used mechanism- = do doDerivInstErrorChecks1 cls cls_tys tycon tc_args rep_tc mtheta- strat_used mechanism- loc <- getSrcSpanM- dfun_name <- newDFunName' cls tycon+ -> DerivM EarlyDerivSpec+mk_data_eqn mechanism+ = do DerivEnv { denv_overlap_mode = overlap_mode+ , denv_tvs = tvs+ , denv_tc = tc+ , denv_tc_args = tc_args+ , denv_rep_tc = rep_tc+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_mtheta = mtheta } <- ask+ let inst_ty = mkTyConApp tc tc_args+ inst_tys = cls_tys ++ [inst_ty]+ doDerivInstErrorChecks1 mechanism+ loc <- lift getSrcSpanM+ dfun_name <- lift $ newDFunName' cls tc case mtheta of Nothing -> -- Infer context do { (inferred_constraints, tvs', inst_tys')- <- inferConstraints tvs cls cls_tys inst_ty- rep_tc rep_tc_args mechanism+ <- inferConstraints mechanism ; return $ InferTheta $ DS { ds_loc = loc , ds_name = dfun_name, ds_tvs = tvs'@@ -1031,59 +1098,67 @@ , ds_theta = theta , ds_overlap = overlap_mode , ds_mechanism = mechanism }- where- inst_ty = mkTyConApp tycon tc_args- inst_tys = cls_tys ++ [inst_ty] -mk_eqn_stock :: DynFlags -> DerivContext -> Class -> [Type] -> TyCon- -> (DerivSpecMechanism -> TcRn EarlyDerivSpec)- -> (SDoc -> TcRn EarlyDerivSpec)- -> TcRn EarlyDerivSpec-mk_eqn_stock dflags mtheta cls cls_tys rep_tc go_for_it bale_out- = case checkSideConditions dflags mtheta cls cls_tys rep_tc of- CanDerive -> mk_eqn_stock' cls go_for_it- DerivableClassError msg -> bale_out msg- _ -> bale_out (nonStdErr cls)+mk_eqn_stock :: (DerivSpecMechanism -> DerivM EarlyDerivSpec)+ -> (SDoc -> DerivM EarlyDerivSpec)+ -> DerivM EarlyDerivSpec+mk_eqn_stock go_for_it bale_out+ = do DerivEnv { denv_rep_tc = rep_tc+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_mtheta = mtheta } <- ask+ dflags <- getDynFlags+ case checkSideConditions dflags mtheta cls cls_tys rep_tc of+ CanDerive -> mk_eqn_stock' go_for_it+ DerivableClassError msg -> bale_out msg+ _ -> bale_out (nonStdErr cls) -mk_eqn_stock' :: Class -> (DerivSpecMechanism -> TcRn EarlyDerivSpec)- -> TcRn EarlyDerivSpec-mk_eqn_stock' cls go_for_it- = go_for_it $ case hasStockDeriving cls of- Just gen_fn -> DerivSpecStock gen_fn- Nothing ->- pprPanic "mk_eqn_stock': Not a stock class!" (ppr cls)+mk_eqn_stock' :: (DerivSpecMechanism -> DerivM EarlyDerivSpec)+ -> DerivM EarlyDerivSpec+mk_eqn_stock' go_for_it+ = do cls <- asks denv_cls+ go_for_it $+ case hasStockDeriving cls of+ Just gen_fn -> DerivSpecStock gen_fn+ Nothing ->+ pprPanic "mk_eqn_stock': Not a stock class!" (ppr cls) -mk_eqn_anyclass :: DynFlags- -> (DerivSpecMechanism -> TcRn EarlyDerivSpec)- -> (SDoc -> TcRn EarlyDerivSpec)- -> TcRn EarlyDerivSpec-mk_eqn_anyclass dflags go_for_it bale_out- = case canDeriveAnyClass dflags of- IsValid -> go_for_it DerivSpecAnyClass- NotValid msg -> bale_out msg+mk_eqn_anyclass :: (DerivSpecMechanism -> DerivM EarlyDerivSpec)+ -> (SDoc -> DerivM EarlyDerivSpec)+ -> DerivM EarlyDerivSpec+mk_eqn_anyclass go_for_it bale_out+ = do dflags <- getDynFlags+ case canDeriveAnyClass dflags of+ IsValid -> go_for_it DerivSpecAnyClass+ NotValid msg -> bale_out msg -mk_eqn_no_mechanism :: DynFlags -> TyCon -> DerivContext- -> Class -> [Type] -> TyCon- -> (DerivSpecMechanism -> TcRn EarlyDerivSpec)- -> (SDoc -> TcRn EarlyDerivSpec)- -> TcRn EarlyDerivSpec-mk_eqn_no_mechanism dflags tc mtheta cls cls_tys rep_tc go_for_it bale_out- = case checkSideConditions dflags mtheta cls cls_tys rep_tc of- -- NB: pass the *representation* tycon to checkSideConditions- NonDerivableClass msg -> bale_out (dac_error msg)- DerivableClassError msg -> bale_out msg- CanDerive -> mk_eqn_stock' cls go_for_it- DerivableViaInstance -> go_for_it DerivSpecAnyClass- where- -- See Note [Deriving instances for classes themselves]- dac_error msg- | isClassTyCon rep_tc- = quotes (ppr tc) <+> text "is a type class,"- <+> text "and can only have a derived instance"- $+$ text "if DeriveAnyClass is enabled"- | otherwise- = nonStdErr cls $$ msg+mk_eqn_no_mechanism :: (DerivSpecMechanism -> DerivM EarlyDerivSpec)+ -> (SDoc -> DerivM EarlyDerivSpec)+ -> DerivM EarlyDerivSpec+mk_eqn_no_mechanism go_for_it bale_out+ = do DerivEnv { denv_tc = tc+ , denv_rep_tc = rep_tc+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_mtheta = mtheta } <- ask+ dflags <- getDynFlags + -- See Note [Deriving instances for classes themselves]+ let dac_error msg+ | isClassTyCon rep_tc+ = quotes (ppr tc) <+> text "is a type class,"+ <+> text "and can only have a derived instance"+ $+$ text "if DeriveAnyClass is enabled"+ | otherwise+ = nonStdErr cls $$ msg++ case checkSideConditions dflags mtheta cls cls_tys rep_tc of+ -- NB: pass the *representation* tycon to checkSideConditions+ NonDerivableClass msg -> bale_out (dac_error msg)+ DerivableClassError msg -> bale_out msg+ CanDerive -> mk_eqn_stock' go_for_it+ DerivableViaInstance -> go_for_it DerivSpecAnyClass+ {- ************************************************************************ * *@@ -1092,245 +1167,266 @@ ************************************************************************ -} -mkNewTypeEqn :: DynFlags -> Maybe OverlapMode -> [TyVar] -> Class- -> [Type] -> TyCon -> [Type] -> TyCon -> [Type]- -> DerivContext -> Maybe DerivStrategy- -> TcRn EarlyDerivSpec-mkNewTypeEqn dflags overlap_mode tvs- cls cls_tys tycon tc_args rep_tycon rep_tc_args- mtheta deriv_strat+mkNewTypeEqn :: DerivM EarlyDerivSpec+mkNewTypeEqn -- Want: instance (...) => cls (cls_tys ++ [tycon tc_args]) where ...- = ASSERT( length cls_tys + 1 == classArity cls )- case deriv_strat of- Just StockStrategy -> mk_eqn_stock dflags mtheta cls cls_tys rep_tycon- go_for_it_other bale_out- Just AnyclassStrategy -> mk_eqn_anyclass dflags go_for_it_other bale_out- Just NewtypeStrategy ->- -- Since the user explicitly asked for GeneralizedNewtypeDeriving, we- -- don't need to perform all of the checks we normally would, such as- -- if the class being derived is known to produce ill-roled coercions- -- (e.g., Traversable), since we can just derive the instance and let- -- it error if need be.- -- See Note [Determining whether newtype-deriving is appropriate]- if coercion_looks_sensible && newtype_deriving- then go_for_it_gnd- else bale_out (cant_derive_err $$- if newtype_deriving then empty else suggest_gnd)- Nothing- | might_derive_via_coercible- && ((newtype_deriving && not deriveAnyClass)- || std_class_via_coercible cls)- -> go_for_it_gnd- | otherwise- -> case checkSideConditions dflags mtheta cls cls_tys rep_tycon of- DerivableClassError msg- -- There's a particular corner case where- --- -- 1. -XGeneralizedNewtypeDeriving and -XDeriveAnyClass are both- -- enabled at the same time- -- 2. We're deriving a particular stock derivable class- -- (such as Functor)- --- -- and the previous cases won't catch it. This fixes the bug- -- reported in Trac #10598.- | might_derive_via_coercible && newtype_deriving- -> go_for_it_gnd- -- Otherwise, throw an error for a stock class- | might_derive_via_coercible && not newtype_deriving- -> bale_out (msg $$ suggest_gnd)- | otherwise- -> bale_out msg+ = do DerivEnv { denv_overlap_mode = overlap_mode+ , denv_tvs = tvs+ , denv_tc = tycon+ , denv_tc_args = tc_args+ , denv_rep_tc = rep_tycon+ , denv_rep_tc_args = rep_tc_args+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_mtheta = mtheta+ , denv_strat = mb_strat } <- ask+ dflags <- getDynFlags - -- Must use newtype deriving or DeriveAnyClass- NonDerivableClass _msg- -- Too hard, even with newtype deriving- | newtype_deriving -> bale_out cant_derive_err- -- Try newtype deriving!- -- Here we suggest GeneralizedNewtypeDeriving even in cases where- -- it may not be applicable. See Trac #9600.- | otherwise -> bale_out (non_std $$ suggest_gnd)+ let newtype_deriving = xopt LangExt.GeneralizedNewtypeDeriving dflags+ deriveAnyClass = xopt LangExt.DeriveAnyClass dflags+ go_for_it_gnd = do+ lift $ traceTc "newtype deriving:" $+ ppr tycon <+> ppr rep_tys <+> ppr all_thetas+ let mechanism = DerivSpecNewtype rep_inst_ty+ doDerivInstErrorChecks1 mechanism+ dfun_name <- lift $ newDFunName' cls tycon+ loc <- lift getSrcSpanM+ case mtheta of+ Just theta -> return $ GivenTheta $ DS+ { ds_loc = loc+ , ds_name = dfun_name, ds_tvs = tvs+ , ds_cls = cls, ds_tys = inst_tys+ , ds_tc = rep_tycon+ , ds_theta = theta+ , ds_overlap = overlap_mode+ , ds_mechanism = mechanism }+ Nothing -> return $ InferTheta $ DS+ { ds_loc = loc+ , ds_name = dfun_name, ds_tvs = tvs+ , ds_cls = cls, ds_tys = inst_tys+ , ds_tc = rep_tycon+ , ds_theta = all_thetas+ , ds_overlap = overlap_mode+ , ds_mechanism = mechanism }+ bale_out = bale_out' newtype_deriving+ bale_out' b msg = do err <- derivingThingErrM b msg+ lift $ failWithTc err - -- DerivableViaInstance- DerivableViaInstance -> do- -- If both DeriveAnyClass and GeneralizedNewtypeDeriving are- -- enabled, we take the diplomatic approach of defaulting to- -- DeriveAnyClass, but emitting a warning about the choice.- -- See Note [Deriving strategies]- when (newtype_deriving && deriveAnyClass) $- addWarnTc NoReason $ sep- [ text "Both DeriveAnyClass and"- <+> text "GeneralizedNewtypeDeriving are enabled"- , text "Defaulting to the DeriveAnyClass strategy"- <+> text "for instantiating" <+> ppr cls ]- go_for_it_other DerivSpecAnyClass- -- CanDerive- CanDerive -> mk_eqn_stock' cls go_for_it_other- where- newtype_deriving = xopt LangExt.GeneralizedNewtypeDeriving dflags- deriveAnyClass = xopt LangExt.DeriveAnyClass dflags- go_for_it_gnd = do- traceTc "newtype deriving:" $- ppr tycon <+> ppr rep_tys <+> ppr all_thetas- let mechanism = DerivSpecNewtype rep_inst_ty- doDerivInstErrorChecks1 cls cls_tys tycon tc_args rep_tycon mtheta- strat_used mechanism- dfun_name <- newDFunName' cls tycon- loc <- getSrcSpanM- case mtheta of- Just theta -> return $ GivenTheta $ DS- { ds_loc = loc- , ds_name = dfun_name, ds_tvs = tvs- , ds_cls = cls, ds_tys = inst_tys- , ds_tc = rep_tycon- , ds_theta = theta- , ds_overlap = overlap_mode- , ds_mechanism = mechanism }- Nothing -> return $ InferTheta $ DS- { ds_loc = loc- , ds_name = dfun_name, ds_tvs = tvs- , ds_cls = cls, ds_tys = inst_tys- , ds_tc = rep_tycon- , ds_theta = all_thetas- , ds_overlap = overlap_mode- , ds_mechanism = mechanism }- go_for_it_other = mk_data_eqn overlap_mode tvs cls cls_tys tycon- tc_args rep_tycon rep_tc_args mtheta strat_used- bale_out = bale_out' newtype_deriving- bale_out' b = failWithTc . derivingThingErr b cls cls_tys inst_ty- deriv_strat+ non_std = nonStdErr cls+ suggest_gnd = text "Try GeneralizedNewtypeDeriving for GHC's"+ <+> text "newtype-deriving extension" - strat_used = isJust deriv_strat- non_std = nonStdErr cls- suggest_gnd = text "Try GeneralizedNewtypeDeriving for GHC's newtype-deriving extension"+ -- Here is the plan for newtype derivings. We see+ -- newtype T a1...an = MkT (t ak+1...an)+ -- deriving (.., C s1 .. sm, ...)+ -- where t is a type,+ -- ak+1...an is a suffix of a1..an, and are all tyvars+ -- ak+1...an do not occur free in t, nor in the s1..sm+ -- (C s1 ... sm) is a *partial applications* of class C+ -- with the last parameter missing+ -- (T a1 .. ak) matches the kind of C's last argument+ -- (and hence so does t)+ -- The latter kind-check has been done by deriveTyData already,+ -- and tc_args are already trimmed+ --+ -- We generate the instance+ -- instance forall ({a1..ak} u fvs(s1..sm)).+ -- C s1 .. sm t => C s1 .. sm (T a1...ak)+ -- where T a1...ap is the partial application of+ -- the LHS of the correct kind and p >= k+ --+ -- NB: the variables below are:+ -- tc_tvs = [a1, ..., an]+ -- tyvars_to_keep = [a1, ..., ak]+ -- rep_ty = t ak .. an+ -- deriv_tvs = fvs(s1..sm) \ tc_tvs+ -- tys = [s1, ..., sm]+ -- rep_fn' = t+ --+ -- Running example: newtype T s a = MkT (ST s a) deriving( Monad )+ -- We generate the instance+ -- instance Monad (ST s) => Monad (T s) where - -- Here is the plan for newtype derivings. We see- -- newtype T a1...an = MkT (t ak+1...an) deriving (.., C s1 .. sm, ...)- -- where t is a type,- -- ak+1...an is a suffix of a1..an, and are all tyvars- -- ak+1...an do not occur free in t, nor in the s1..sm- -- (C s1 ... sm) is a *partial applications* of class C- -- with the last parameter missing- -- (T a1 .. ak) matches the kind of C's last argument- -- (and hence so does t)- -- The latter kind-check has been done by deriveTyData already,- -- and tc_args are already trimmed- --- -- We generate the instance- -- instance forall ({a1..ak} u fvs(s1..sm)).- -- C s1 .. sm t => C s1 .. sm (T a1...ak)- -- where T a1...ap is the partial application of- -- the LHS of the correct kind and p >= k- --- -- NB: the variables below are:- -- tc_tvs = [a1, ..., an]- -- tyvars_to_keep = [a1, ..., ak]- -- rep_ty = t ak .. an- -- deriv_tvs = fvs(s1..sm) \ tc_tvs- -- tys = [s1, ..., sm]- -- rep_fn' = t- --- -- Running example: newtype T s a = MkT (ST s a) deriving( Monad )- -- We generate the instance- -- instance Monad (ST s) => Monad (T s) where+ nt_eta_arity = newTyConEtadArity rep_tycon+ -- For newtype T a b = MkT (S a a b), the TyCon+ -- machinery already eta-reduces the representation type, so+ -- we know that+ -- T a ~ S a a+ -- That's convenient here, because we may have to apply+ -- it to fewer than its original complement of arguments - nt_eta_arity = newTyConEtadArity rep_tycon- -- For newtype T a b = MkT (S a a b), the TyCon machinery already- -- eta-reduces the representation type, so we know that- -- T a ~ S a a- -- That's convenient here, because we may have to apply- -- it to fewer than its original complement of arguments+ -- Note [Newtype representation]+ -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+ -- Need newTyConRhs (*not* a recursive representation finder)+ -- to get the representation type. For example+ -- newtype B = MkB Int+ -- newtype A = MkA B deriving( Num )+ -- We want the Num instance of B, *not* the Num instance of Int,+ -- when making the Num instance of A!+ rep_inst_ty = newTyConInstRhs rep_tycon rep_tc_args+ rep_tys = cls_tys ++ [rep_inst_ty]+ rep_pred = mkClassPred cls rep_tys+ rep_pred_o = mkPredOrigin DerivOrigin TypeLevel rep_pred+ -- rep_pred is the representation dictionary, from where+ -- we are gong to get all the methods for the newtype+ -- dictionary - -- Note [Newtype representation]- -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~- -- Need newTyConRhs (*not* a recursive representation finder)- -- to get the representation type. For example- -- newtype B = MkB Int- -- newtype A = MkA B deriving( Num )- -- We want the Num instance of B, *not* the Num instance of Int,- -- when making the Num instance of A!- rep_inst_ty = newTyConInstRhs rep_tycon rep_tc_args- rep_tys = cls_tys ++ [rep_inst_ty]- rep_pred = mkClassPred cls rep_tys- rep_pred_o = mkPredOrigin DerivOrigin TypeLevel rep_pred- -- rep_pred is the representation dictionary, from where- -- we are gong to get all the methods for the newtype- -- dictionary+ -- Next we figure out what superclass dictionaries to use+ -- See Note [Newtype deriving superclasses] above+ sc_preds :: [PredOrigin]+ cls_tyvars = classTyVars cls+ inst_ty = mkTyConApp tycon tc_args+ inst_tys = cls_tys ++ [inst_ty]+ sc_preds = map (mkPredOrigin DerivOrigin TypeLevel) $+ substTheta (zipTvSubst cls_tyvars inst_tys) $+ classSCTheta cls - -- Next we figure out what superclass dictionaries to use- -- See Note [Newtype deriving superclasses] above- sc_preds :: [PredOrigin]- cls_tyvars = classTyVars cls- inst_ty = mkTyConApp tycon tc_args- inst_tys = cls_tys ++ [inst_ty]- sc_preds = map (mkPredOrigin DerivOrigin TypeLevel) $- substTheta (zipTvSubst cls_tyvars inst_tys) $- classSCTheta cls+ -- Next we collect constraints for the class methods+ -- If there are no methods, we don't need any constraints+ -- Otherwise we need (C rep_ty), for the representation methods,+ -- and constraints to coerce each individual method+ meth_preds :: [PredOrigin]+ meths = classMethods cls+ meth_preds | null meths = [] -- No methods => no constraints+ -- (Trac #12814)+ | otherwise = rep_pred_o : coercible_constraints+ coercible_constraints+ = [ mkPredOrigin (DerivOriginCoerce meth t1 t2) TypeLevel+ (mkReprPrimEqPred t1 t2)+ | meth <- meths+ , let (Pair t1 t2) = mkCoerceClassMethEqn cls tvs+ inst_tys rep_inst_ty meth ] - -- Next we collect constraints for the class methods- -- If there are no methods, we don't need any constraints- -- Otherwise we need (C rep_ty), for the representation methods,- -- and constraints to coerce each individual method- meth_preds :: [PredOrigin]- meths = classMethods cls- meth_preds | null meths = [] -- No methods => no constraints- -- (Trac #12814)- | otherwise = rep_pred_o : coercible_constraints- coercible_constraints- = [ mkPredOrigin (DerivOriginCoerce meth t1 t2) TypeLevel- (mkReprPrimEqPred t1 t2)- | meth <- meths- , let (Pair t1 t2) = mkCoerceClassMethEqn cls tvs- inst_tys rep_inst_ty meth ]+ all_thetas :: [ThetaOrigin]+ all_thetas = [mkThetaOriginFromPreds $ meth_preds ++ sc_preds] - all_thetas :: [ThetaOrigin]- all_thetas = [mkThetaOriginFromPreds $ meth_preds ++ sc_preds]+ -------------------------------------------------------------------+ -- Figuring out whether we can only do this newtype-deriving thing - -------------------------------------------------------------------- -- Figuring out whether we can only do this newtype-deriving thing+ -- See Note [Determining whether newtype-deriving is appropriate]+ might_derive_via_coercible+ = not (non_coercible_class cls)+ && coercion_looks_sensible+-- && not (isRecursiveTyCon tycon) -- Note [Recursive newtypes]+ coercion_looks_sensible+ = eta_ok+ -- Check (a) from Note [GND and associated type families]+ && ats_ok+ -- Check (b) from Note [GND and associated type families]+ && isNothing at_without_last_cls_tv+ -- Check (d) from Note [GND and associated type families]+ && isNothing at_last_cls_tv_in_kinds - -- See Note [Determining whether newtype-deriving is appropriate]- might_derive_via_coercible- = not (non_coercible_class cls)- && coercion_looks_sensible--- && not (isRecursiveTyCon tycon) -- Note [Recursive newtypes]- coercion_looks_sensible- = eta_ok- -- Check (a) from Note [GND and associated type families]- && ats_ok- -- Check (b) from Note [GND and associated type families]- && isNothing at_without_last_cls_tv+ -- Check that eta reduction is OK+ eta_ok = rep_tc_args `lengthAtLeast` nt_eta_arity+ -- The newtype can be eta-reduced to match the number+ -- of type argument actually supplied+ -- newtype T a b = MkT (S [a] b) deriving( Monad )+ -- Here the 'b' must be the same in the rep type (S [a] b)+ -- And the [a] must not mention 'b'. That's all handled+ -- by nt_eta_rity. - -- Check that eta reduction is OK- eta_ok = nt_eta_arity <= length rep_tc_args- -- The newtype can be eta-reduced to match the number- -- of type argument actually supplied- -- newtype T a b = MkT (S [a] b) deriving( Monad )- -- Here the 'b' must be the same in the rep type (S [a] b)- -- And the [a] must not mention 'b'. That's all handled- -- by nt_eta_rity.+ (adf_tcs, atf_tcs) = partition isDataFamilyTyCon at_tcs+ ats_ok = null adf_tcs+ -- We cannot newtype-derive data family instances - (adf_tcs, atf_tcs) = partition isDataFamilyTyCon at_tcs- ats_ok = null adf_tcs- -- We cannot newtype-derive data family instances+ at_without_last_cls_tv+ = find (\tc -> last_cls_tv `notElem` tyConTyVars tc) atf_tcs+ at_last_cls_tv_in_kinds+ = find (\tc -> any (at_last_cls_tv_in_kind . tyVarKind)+ (tyConTyVars tc)+ || at_last_cls_tv_in_kind (tyConResKind tc)) atf_tcs+ at_last_cls_tv_in_kind kind+ = last_cls_tv `elemVarSet` exactTyCoVarsOfType kind+ at_tcs = classATs cls+ last_cls_tv = ASSERT( notNull cls_tyvars )+ last cls_tyvars - at_without_last_cls_tv- = find (\tc -> last_cls_tv `notElem` tyConTyVars tc) atf_tcs- at_tcs = classATs cls- last_cls_tv = ASSERT( notNull cls_tyvars )- last cls_tyvars+ cant_derive_err+ = vcat [ ppUnless eta_ok eta_msg+ , ppUnless ats_ok ats_msg+ , maybe empty at_without_last_cls_tv_msg+ at_without_last_cls_tv+ , maybe empty at_last_cls_tv_in_kinds_msg+ at_last_cls_tv_in_kinds+ ]+ eta_msg = text "cannot eta-reduce the representation type enough"+ ats_msg = text "the class has associated data types"+ at_without_last_cls_tv_msg at_tc = hang+ (text "the associated type" <+> quotes (ppr at_tc)+ <+> text "is not parameterized over the last type variable")+ 2 (text "of the class" <+> quotes (ppr cls))+ at_last_cls_tv_in_kinds_msg at_tc = hang+ (text "the associated type" <+> quotes (ppr at_tc)+ <+> text "contains the last type variable")+ 2 (text "of the class" <+> quotes (ppr cls)+ <+> text "in a kind, which is not (yet) allowed") - cant_derive_err- = vcat [ ppUnless eta_ok eta_msg- , ppUnless ats_ok ats_msg- , maybe empty at_tv_msg- at_without_last_cls_tv]- eta_msg = text "cannot eta-reduce the representation type enough"- ats_msg = text "the class has associated data types"- at_tv_msg at_tc = hang- (text "the associated type" <+> quotes (ppr at_tc)- <+> text "is not parameterized over the last type variable")- 2 (text "of the class" <+> quotes (ppr cls))+ MASSERT( cls_tys `lengthIs` (classArity cls - 1) )+ case mb_strat of+ Just StockStrategy -> mk_eqn_stock mk_data_eqn bale_out+ Just AnyclassStrategy -> mk_eqn_anyclass mk_data_eqn bale_out+ Just NewtypeStrategy ->+ -- Since the user explicitly asked for GeneralizedNewtypeDeriving,+ -- we don't need to perform all of the checks we normally would,+ -- such as if the class being derived is known to produce ill-roled+ -- coercions (e.g., Traversable), since we can just derive the+ -- instance and let it error if need be.+ -- See Note [Determining whether newtype-deriving is appropriate]+ if coercion_looks_sensible && newtype_deriving+ then go_for_it_gnd+ else bale_out (cant_derive_err $$+ if newtype_deriving then empty else suggest_gnd)+ Nothing+ | might_derive_via_coercible+ && ((newtype_deriving && not deriveAnyClass)+ || std_class_via_coercible cls)+ -> go_for_it_gnd+ | otherwise+ -> case checkSideConditions dflags mtheta cls cls_tys rep_tycon of+ DerivableClassError msg+ -- There's a particular corner case where+ --+ -- 1. -XGeneralizedNewtypeDeriving and -XDeriveAnyClass are+ -- both enabled at the same time+ -- 2. We're deriving a particular stock derivable class+ -- (such as Functor)+ --+ -- and the previous cases won't catch it. This fixes the bug+ -- reported in Trac #10598.+ | might_derive_via_coercible && newtype_deriving+ -> go_for_it_gnd+ -- Otherwise, throw an error for a stock class+ | might_derive_via_coercible && not newtype_deriving+ -> bale_out (msg $$ suggest_gnd)+ | otherwise+ -> bale_out msg + -- Must use newtype deriving or DeriveAnyClass+ NonDerivableClass _msg+ -- Too hard, even with newtype deriving+ | newtype_deriving -> bale_out cant_derive_err+ -- Try newtype deriving!+ -- Here we suggest GeneralizedNewtypeDeriving even in cases+ -- where it may not be applicable. See Trac #9600.+ | otherwise -> bale_out (non_std $$ suggest_gnd)++ -- DerivableViaInstance+ DerivableViaInstance -> do+ -- If both DeriveAnyClass and GeneralizedNewtypeDeriving are+ -- enabled, we take the diplomatic approach of defaulting to+ -- DeriveAnyClass, but emitting a warning about the choice.+ -- See Note [Deriving strategies]+ when (newtype_deriving && deriveAnyClass) $+ lift $ addWarnTc NoReason $ sep+ [ text "Both DeriveAnyClass and"+ <+> text "GeneralizedNewtypeDeriving are enabled"+ , text "Defaulting to the DeriveAnyClass strategy"+ <+> text "for instantiating" <+> ppr cls ]+ mk_data_eqn DerivSpecAnyClass+ -- CanDerive+ CanDerive -> mk_eqn_stock' mk_data_eqn+ {- Note [Recursive newtypes] ~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1450,6 +1546,27 @@ GHC's termination checker isn't sophisticated enough to conclude that the definition of T MyInt terminates, so UndecidableInstances is required. +(d) For the time being, we do not allow the last type variable of the class to+ appear in a /kind/ of an associated type family definition. For instance:++ class C a where+ type T1 a -- OK+ type T2 (x :: a) -- Illegal: a appears in the kind of x+ type T3 y :: a -- Illegal: a appears in the kind of (T3 y)++ The reason we disallow this is because our current approach to deriving+ associated type family instances—i.e., by unwrapping the newtype's type+ constructor as shown above—is ill-equipped to handle the scenario when+ the last type variable appears as an implicit argument. In the worst case,+ allowing the last variable to appear in a kind can result in improper Core+ being generated (see #14728).++ There is hope for this feature being added some day, as one could+ conceivably take a newtype axiom (which witnesses a coercion between a+ newtype and its representation type) at lift that through each associated+ type at the Core level. See #14728, comment:3 for a sketch of how this+ might work. Until then, we disallow this featurette wholesale.+ ************************************************************************ * * \subsection[TcDeriv-normal-binds]{Bindings for the various classes}@@ -1521,16 +1638,17 @@ -- case of instances for indexed families. -- genInst :: DerivSpec theta- -> TcM (ThetaType -> TcM (InstInfo RdrName), BagDerivStuff, Maybe Name)+ -> TcM (ThetaType -> TcM (InstInfo GhcPs), BagDerivStuff, [Name]) -- We must use continuation-returning style here to get the order in which we -- typecheck family instances and derived instances right. -- See Note [Staging of tcDeriving] genInst spec@(DS { ds_tvs = tvs, ds_tc = rep_tycon , ds_mechanism = mechanism, ds_tys = tys , ds_cls = clas, ds_loc = loc })- = do (meth_binds, deriv_stuff) <- genDerivStuff mechanism loc clas- rep_tycon tys tvs- let mk_inst_info theta = do+ = do (meth_binds, deriv_stuff, unusedNames)+ <- set_span_and_ctxt $+ genDerivStuff mechanism loc clas rep_tycon tys tvs+ let mk_inst_info theta = set_span_and_ctxt $ do inst_spec <- newDerivClsInst theta spec doDerivInstErrorChecks2 clas inst_spec mechanism traceTc "newder" (ppr inst_spec)@@ -1542,16 +1660,8 @@ , ib_pragmas = [] , ib_extensions = extensions , ib_derived = True } }- return (mk_inst_info, deriv_stuff, unusedConName)+ return (mk_inst_info, deriv_stuff, unusedNames) where- unusedConName :: Maybe Name- unusedConName- | isDerivSpecNewtype mechanism- -- See Note [Newtype deriving and unused constructors]- = Just $ getName $ head $ tyConDataCons rep_tycon- | otherwise- = Nothing- extensions :: [LangExt.Extension] extensions | isDerivSpecNewtype mechanism@@ -1561,32 +1671,35 @@ | otherwise = [] -doDerivInstErrorChecks1 :: Class -> [Type] -> TyCon -> [Type] -> TyCon- -> DerivContext -> Bool -> DerivSpecMechanism- -> TcM ()-doDerivInstErrorChecks1 cls cls_tys tc tc_args rep_tc mtheta- strat_used mechanism = do+ set_span_and_ctxt :: TcM a -> TcM a+ set_span_and_ctxt = setSrcSpan loc . addErrCtxt (instDeclCtxt3 clas tys)++doDerivInstErrorChecks1 :: DerivSpecMechanism -> DerivM ()+doDerivInstErrorChecks1 mechanism = do+ DerivEnv { denv_tc = tc+ , denv_rep_tc = rep_tc+ , denv_mtheta = mtheta } <- ask+ let anyclass_strategy = isDerivSpecAnyClass mechanism+ bale_out msg = do err <- derivingThingErrMechanism mechanism msg+ lift $ failWithTc err+ -- For standalone deriving (mtheta /= Nothing), -- check that all the data constructors are in scope...- rdr_env <- getGlobalRdrEnv+ rdr_env <- lift getGlobalRdrEnv let data_con_names = map dataConName (tyConDataCons rep_tc) hidden_data_cons = not (isWiredInName (tyConName rep_tc)) && (isAbstractTyCon rep_tc || any not_in_scope data_con_names) not_in_scope dc = isNothing (lookupGRE_Name rdr_env dc) - addUsedDataCons rdr_env rep_tc+ lift $ addUsedDataCons rdr_env rep_tc+ -- ...however, we don't perform this check if we're using DeriveAnyClass, -- since it doesn't generate any code that requires use of a data -- constructor. unless (anyclass_strategy || isNothing mtheta || not hidden_data_cons) $ bale_out $ derivingHiddenErr tc- where- anyclass_strategy = isDerivSpecAnyClass mechanism - bale_out msg = failWithTc (derivingThingErrMechanism cls cls_tys- (mkTyConApp tc tc_args) strat_used mechanism msg)- doDerivInstErrorChecks2 :: Class -> ClsInst -> DerivSpecMechanism -> TcM () doDerivInstErrorChecks2 clas clas_inst mechanism = do { traceTc "doDerivInstErrorChecks2" (ppr clas_inst)@@ -1602,19 +1715,18 @@ DerivSpecStock{} -> False _ -> True - gen_inst_err = hang (text ("Generic instances can only be derived in "- ++ "Safe Haskell using the stock strategy.") $+$- text "In the following instance:")- 2 (pprInstanceHdr clas_inst)+ gen_inst_err = text "Generic instances can only be derived in"+ <+> text "Safe Haskell using the stock strategy." genDerivStuff :: DerivSpecMechanism -> SrcSpan -> Class -> TyCon -> [Type] -> [TyVar]- -> TcM (LHsBinds RdrName, BagDerivStuff)+ -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]) genDerivStuff mechanism loc clas tycon inst_tys tyvars = case mechanism of -- See Note [Bindings for Generalised Newtype Deriving]- DerivSpecNewtype rhs_ty -> gen_Newtype_binds loc clas tyvars- inst_tys rhs_ty+ DerivSpecNewtype rhs_ty -> do+ (binds, faminsts) <- gen_Newtype_binds loc clas tyvars inst_tys rhs_ty+ return (binds, faminsts, maybeToList unusedConName) -- Try a stock deriver DerivSpecStock gen_fn -> gen_fn loc tycon inst_tys@@ -1630,14 +1742,22 @@ -- unless -XDeriveAnyClass is enabled. ASSERT2( isValid (canDeriveAnyClass dflags) , ppr "genDerivStuff: bad derived class" <+> ppr clas )- mapM (tcATDefault False loc mini_subst emptyNameSet)+ mapM (tcATDefault loc mini_subst emptyNameSet) (classATItems clas) return ( emptyBag -- No method bindings are needed... , listToBag (map DerivFamInst (concat tyfam_insts)) -- ...but we may need to generate binding for associated type -- family default instances. -- See Note [DeriveAnyClass and default family instances]- )+ , [] )+ where+ unusedConName :: Maybe Name+ unusedConName+ | isDerivSpecNewtype mechanism+ -- See Note [Newtype deriving and unused constructors]+ = Just $ getName $ head $ tyConDataCons tycon+ | otherwise+ = Nothing {- Note [Bindings for Generalised Newtype Deriving]@@ -1683,8 +1803,8 @@ In the latter case, we must take care to check if C has any associated type families with default instances, because -XDeriveAnyClass will never provide an implementation for them. We "fill in" the default instances using the-tcATDefault function from TcClsDcl (which is also used in TcInstDcls to handle-the empty instance declaration case).+tcATDefault function from TcClassDcl (which is also used in TcInstDcls to+handle the empty instance declaration case). Note [Deriving strategies] ~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1760,7 +1880,7 @@ ************************************************************************ -} -nonUnaryErr :: LHsSigType Name -> SDoc+nonUnaryErr :: LHsSigType GhcRn -> SDoc nonUnaryErr ct = quotes (ppr ct) <+> text "is not a unary constraint, as expected by a deriving clause" @@ -1797,33 +1917,45 @@ nest 2 (text "instance (...) =>" <+> pprClassPred cls (cls_tys ++ [inst_ty]))] -derivingThingErr :: Bool -> Class -> [Type] -> Type -> Maybe DerivStrategy- -> MsgDoc -> MsgDoc-derivingThingErr newtype_deriving clas tys ty deriv_strat why- = derivingThingErr' newtype_deriving clas tys ty (isJust deriv_strat)- (maybe empty ppr deriv_strat) why+derivingThingErr :: Bool -> Class -> [Type] -> Type+ -> Maybe DerivStrategy -> MsgDoc -> MsgDoc+derivingThingErr newtype_deriving cls cls_tys inst_ty mb_strat why+ = derivingThingErr' newtype_deriving cls cls_tys inst_ty mb_strat+ (maybe empty ppr mb_strat) why -derivingThingErrMechanism :: Class -> [Type] -> Type- -> Bool -- True if an explicit deriving strategy- -- keyword was provided- -> DerivSpecMechanism- -> MsgDoc -> MsgDoc-derivingThingErrMechanism clas tys ty strat_used mechanism why- = derivingThingErr' (isDerivSpecNewtype mechanism) clas tys ty strat_used- (ppr mechanism) why+derivingThingErrM :: Bool -> MsgDoc -> DerivM MsgDoc+derivingThingErrM newtype_deriving why+ = do DerivEnv { denv_tc = tc+ , denv_tc_args = tc_args+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_strat = mb_strat } <- ask+ pure $ derivingThingErr newtype_deriving cls cls_tys+ (mkTyConApp tc tc_args) mb_strat why -derivingThingErr' :: Bool -> Class -> [Type] -> Type -> Bool -> MsgDoc- -> MsgDoc -> MsgDoc-derivingThingErr' newtype_deriving clas tys ty strat_used strat_msg why+derivingThingErrMechanism :: DerivSpecMechanism -> MsgDoc -> DerivM MsgDoc+derivingThingErrMechanism mechanism why+ = do DerivEnv { denv_tc = tc+ , denv_tc_args = tc_args+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_strat = mb_strat } <- ask+ pure $ derivingThingErr' (isDerivSpecNewtype mechanism) cls cls_tys+ (mkTyConApp tc tc_args) mb_strat (ppr mechanism) why++derivingThingErr' :: Bool -> Class -> [Type] -> Type+ -> Maybe DerivStrategy -> MsgDoc -> MsgDoc -> MsgDoc+derivingThingErr' newtype_deriving cls cls_tys inst_ty mb_strat strat_msg why = sep [(hang (text "Can't make a derived instance of") 2 (quotes (ppr pred) <+> via_mechanism) $$ nest 2 extra) <> colon, nest 2 why] where+ strat_used = isJust mb_strat extra | not strat_used, newtype_deriving = text "(even with cunning GeneralizedNewtypeDeriving)" | otherwise = empty- pred = mkClassPred clas (tys ++ [ty])+ pred = mkClassPred cls (cls_tys ++ [inst_ty]) via_mechanism | strat_used = text "with the" <+> strat_msg <+> text "strategy" | otherwise@@ -1834,7 +1966,7 @@ = hang (text "The data constructors of" <+> quotes (ppr tc) <+> ptext (sLit "are not all in scope")) 2 (text "so you cannot derive an instance for it") -standaloneCtxt :: LHsSigType Name -> SDoc+standaloneCtxt :: LHsSigType GhcRn -> SDoc standaloneCtxt ty = hang (text "In the stand-alone deriving instance for") 2 (quotes (ppr ty))
typecheck/TcDerivInfer.hs view
@@ -7,11 +7,14 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE MultiWayIf #-} module TcDerivInfer (inferConstraints, simplifyInstanceContexts) where #include "HsVersions.h" +import GhcPrelude+ import Bag import BasicTypes import Class@@ -41,14 +44,15 @@ import VarSet import Control.Monad+import Control.Monad.Trans.Class (lift)+import Control.Monad.Trans.Reader (ask) import Data.List import Data.Maybe ---------------------- -inferConstraints :: [TyVar] -> Class -> [TcType] -> TcType- -> TyCon -> [TcType] -> DerivSpecMechanism- -> TcM ([ThetaOrigin], [TyVar], [TcType])+inferConstraints :: DerivSpecMechanism+ -> DerivM ([ThetaOrigin], [TyVar], [TcType]) -- inferConstraints figures out the constraints needed for the -- instance declaration generated by a 'deriving' clause on a -- data type declaration. It also returns the new in-scope type@@ -64,172 +68,216 @@ -- Generate a sufficiently large set of constraints that typechecking the -- generated method definitions should succeed. This set will be simplified -- before being used in the instance declaration-inferConstraints tvs main_cls cls_tys inst_ty- rep_tc rep_tc_args- mechanism- | is_generic && not is_anyclass -- Generic constraints are easy- = return ([], tvs, inst_tys)-- | is_generic1 && not is_anyclass -- Generic1 needs Functor- = ASSERT( length rep_tc_tvs > 0 ) -- See Note [Getting base classes]- ASSERT( length cls_tys == 1 ) -- Generic1 has a single kind variable- do { functorClass <- tcLookupClass functorClassName- ; con_arg_constraints (get_gen1_constraints functorClass) }+inferConstraints mechanism+ = do { DerivEnv { denv_tc = tc+ , denv_tc_args = tc_args+ , denv_cls = main_cls+ , denv_cls_tys = cls_tys } <- ask+ ; let is_anyclass = isDerivSpecAnyClass mechanism+ infer_constraints+ | is_anyclass = inferConstraintsDAC inst_tys+ | otherwise = inferConstraintsDataConArgs inst_ty inst_tys - | otherwise -- The others are a bit more complicated- = -- See the comment with all_rep_tc_args for an explanation of- -- this assertion- ASSERT2( equalLength rep_tc_tvs all_rep_tc_args- , ppr main_cls <+> ppr rep_tc- $$ ppr rep_tc_tvs $$ ppr all_rep_tc_args )- do { (arg_constraints, tvs', inst_tys') <- infer_constraints- ; traceTc "inferConstraints" $ vcat- [ ppr main_cls <+> ppr inst_tys'- , ppr arg_constraints- ]- ; return (stupid_constraints ++ extra_constraints- ++ sc_constraints ++ arg_constraints- , tvs', inst_tys') }- where- is_anyclass = isDerivSpecAnyClass mechanism- infer_constraints- | is_anyclass = inferConstraintsDAC main_cls tvs inst_tys- | otherwise = con_arg_constraints get_std_constrained_tys+ inst_ty = mkTyConApp tc tc_args+ inst_tys = cls_tys ++ [inst_ty] - tc_binders = tyConBinders rep_tc- choose_level bndr- | isNamedTyConBinder bndr = KindLevel- | otherwise = TypeLevel- t_or_ks = map choose_level tc_binders ++ repeat TypeLevel- -- want to report *kind* errors when possible+ -- Constraints arising from superclasses+ -- See Note [Superclasses of derived instance]+ cls_tvs = classTyVars main_cls+ sc_constraints = ASSERT2( equalLength cls_tvs inst_tys+ , ppr main_cls <+> ppr inst_tys )+ [ mkThetaOrigin DerivOrigin TypeLevel [] [] $+ substTheta cls_subst (classSCTheta main_cls) ]+ cls_subst = ASSERT( equalLength cls_tvs inst_tys )+ zipTvSubst cls_tvs inst_tys - -- Constraints arising from the arguments of each constructor- con_arg_constraints :: (CtOrigin -> TypeOrKind- -> Type- -> [([PredOrigin], Maybe TCvSubst)])- -> TcM ([ThetaOrigin], [TyVar], [TcType])- con_arg_constraints get_arg_constraints- = let (predss, mbSubsts) = unzip- [ preds_and_mbSubst- | data_con <- tyConDataCons rep_tc- , (arg_n, arg_t_or_k, arg_ty)- <- zip3 [1..] t_or_ks $- dataConInstOrigArgTys data_con all_rep_tc_args- -- No constraints for unlifted types- -- See Note [Deriving and unboxed types]- , not (isUnliftedType arg_ty)- , let orig = DerivOriginDC data_con arg_n- , preds_and_mbSubst <- get_arg_constraints orig arg_t_or_k arg_ty+ ; (inferred_constraints, tvs', inst_tys') <- infer_constraints+ ; lift $ traceTc "inferConstraints" $ vcat+ [ ppr main_cls <+> ppr inst_tys'+ , ppr inferred_constraints ]- preds = concat predss- -- If the constraints require a subtype to be of kind (* -> *)- -- (which is the case for functor-like constraints), then we- -- explicitly unify the subtype's kinds with (* -> *).- -- See Note [Inferring the instance context]- subst = foldl' composeTCvSubst- emptyTCvSubst (catMaybes mbSubsts)- unmapped_tvs = filter (\v -> v `notElemTCvSubst` subst- && not (v `isInScope` subst)) tvs- (subst', _) = mapAccumL substTyVarBndr subst unmapped_tvs- preds' = map (substPredOrigin subst') preds- inst_tys' = substTys subst' inst_tys- tvs' = tyCoVarsOfTypesWellScoped inst_tys'- in return ([mkThetaOriginFromPreds preds'], tvs', inst_tys')+ ; return ( sc_constraints ++ inferred_constraints+ , tvs', inst_tys' ) } - is_generic = main_cls `hasKey` genClassKey- is_generic1 = main_cls `hasKey` gen1ClassKey- -- is_functor_like: see Note [Inferring the instance context]- is_functor_like = typeKind inst_ty `tcEqKind` typeToTypeKind- || is_generic1+-- | Like 'inferConstraints', but used only in the case of deriving strategies+-- where the constraints are inferred by inspecting the fields of each data+-- constructor (i.e., stock- and newtype-deriving).+inferConstraintsDataConArgs :: TcType -> [TcType]+ -> DerivM ([ThetaOrigin], [TyVar], [TcType])+inferConstraintsDataConArgs inst_ty inst_tys+ = do DerivEnv { denv_tvs = tvs+ , denv_rep_tc = rep_tc+ , denv_rep_tc_args = rep_tc_args+ , denv_cls = main_cls+ , denv_cls_tys = cls_tys } <- ask - get_gen1_constraints :: Class -> CtOrigin -> TypeOrKind -> Type- -> [([PredOrigin], Maybe TCvSubst)]- get_gen1_constraints functor_cls orig t_or_k ty- = mk_functor_like_constraints orig t_or_k functor_cls $- get_gen1_constrained_tys last_tv ty+ let tc_binders = tyConBinders rep_tc+ choose_level bndr+ | isNamedTyConBinder bndr = KindLevel+ | otherwise = TypeLevel+ t_or_ks = map choose_level tc_binders ++ repeat TypeLevel+ -- want to report *kind* errors when possible - get_std_constrained_tys :: CtOrigin -> TypeOrKind -> Type- -> [([PredOrigin], Maybe TCvSubst)]- get_std_constrained_tys orig t_or_k ty- | is_functor_like = mk_functor_like_constraints orig t_or_k main_cls $- deepSubtypesContaining last_tv ty- | otherwise = [( [mk_cls_pred orig t_or_k main_cls ty]- , Nothing )]+ -- Constraints arising from the arguments of each constructor+ con_arg_constraints+ :: (CtOrigin -> TypeOrKind+ -> Type+ -> [([PredOrigin], Maybe TCvSubst)])+ -> ([ThetaOrigin], [TyVar], [TcType])+ con_arg_constraints get_arg_constraints+ = let (predss, mbSubsts) = unzip+ [ preds_and_mbSubst+ | data_con <- tyConDataCons rep_tc+ , (arg_n, arg_t_or_k, arg_ty)+ <- zip3 [1..] t_or_ks $+ dataConInstOrigArgTys data_con all_rep_tc_args+ -- No constraints for unlifted types+ -- See Note [Deriving and unboxed types]+ , not (isUnliftedType arg_ty)+ , let orig = DerivOriginDC data_con arg_n+ , preds_and_mbSubst+ <- get_arg_constraints orig arg_t_or_k arg_ty+ ]+ preds = concat predss+ -- If the constraints require a subtype to be of kind+ -- (* -> *) (which is the case for functor-like+ -- constraints), then we explicitly unify the subtype's+ -- kinds with (* -> *).+ -- See Note [Inferring the instance context]+ subst = foldl' composeTCvSubst+ emptyTCvSubst (catMaybes mbSubsts)+ unmapped_tvs = filter (\v -> v `notElemTCvSubst` subst+ && not (v `isInScope` subst)) tvs+ (subst', _) = mapAccumL substTyVarBndr subst unmapped_tvs+ preds' = map (substPredOrigin subst') preds+ inst_tys' = substTys subst' inst_tys+ tvs' = tyCoVarsOfTypesWellScoped inst_tys'+ in ([mkThetaOriginFromPreds preds'], tvs', inst_tys') - mk_functor_like_constraints :: CtOrigin -> TypeOrKind- -> Class -> [Type]+ is_generic = main_cls `hasKey` genClassKey+ is_generic1 = main_cls `hasKey` gen1ClassKey+ -- is_functor_like: see Note [Inferring the instance context]+ is_functor_like = typeKind inst_ty `tcEqKind` typeToTypeKind+ || is_generic1++ get_gen1_constraints :: Class -> CtOrigin -> TypeOrKind -> Type -> [([PredOrigin], Maybe TCvSubst)]- -- 'cls' is usually main_cls (Functor or Traversable etc), but if- -- main_cls = Generic1, then 'cls' can be Functor; see get_gen1_constraints- --- -- For each type, generate two constraints, [cls ty, kind(ty) ~ (*->*)],- -- and a kind substitution that results from unifying kind(ty) with * -> *.- -- If the unification is successful, it will ensure that the resulting- -- instance is well kinded. If not, the second constraint will result- -- in an error message which points out the kind mismatch.- -- See Note [Inferring the instance context]- mk_functor_like_constraints orig t_or_k cls- = map $ \ty -> let ki = typeKind ty in- ( [ mk_cls_pred orig t_or_k cls ty- , mkPredOrigin orig KindLevel- (mkPrimEqPred ki typeToTypeKind) ]- , tcUnifyTy ki typeToTypeKind- )+ get_gen1_constraints functor_cls orig t_or_k ty+ = mk_functor_like_constraints orig t_or_k functor_cls $+ get_gen1_constrained_tys last_tv ty - rep_tc_tvs = tyConTyVars rep_tc- last_tv = last rep_tc_tvs- -- When we first gather up the constraints to solve, most of them contain- -- rep_tc_tvs, i.e., the type variables from the derived datatype's type- -- constructor. We don't want these type variables to appear in the final- -- instance declaration, so we must substitute each type variable with its- -- counterpart in the derived instance. rep_tc_args lists each of these- -- counterpart types in the same order as the type variables.- all_rep_tc_args = rep_tc_args ++ map mkTyVarTy- (drop (length rep_tc_args) rep_tc_tvs)+ get_std_constrained_tys :: CtOrigin -> TypeOrKind -> Type+ -> [([PredOrigin], Maybe TCvSubst)]+ get_std_constrained_tys orig t_or_k ty+ | is_functor_like+ = mk_functor_like_constraints orig t_or_k main_cls $+ deepSubtypesContaining last_tv ty+ | otherwise+ = [( [mk_cls_pred orig t_or_k main_cls ty]+ , Nothing )] - -- Constraints arising from superclasses- -- See Note [Superclasses of derived instance]- cls_tvs = classTyVars main_cls- inst_tys = cls_tys ++ [inst_ty]- sc_constraints = ASSERT2( equalLength cls_tvs inst_tys, ppr main_cls <+> ppr rep_tc)- [ mkThetaOrigin DerivOrigin TypeLevel [] [] $- substTheta cls_subst (classSCTheta main_cls) ]- cls_subst = ASSERT( equalLength cls_tvs inst_tys )- zipTvSubst cls_tvs inst_tys+ mk_functor_like_constraints :: CtOrigin -> TypeOrKind+ -> Class -> [Type]+ -> [([PredOrigin], Maybe TCvSubst)]+ -- 'cls' is usually main_cls (Functor or Traversable etc), but if+ -- main_cls = Generic1, then 'cls' can be Functor; see+ -- get_gen1_constraints+ --+ -- For each type, generate two constraints,+ -- [cls ty, kind(ty) ~ (*->*)], and a kind substitution that results+ -- from unifying kind(ty) with * -> *. If the unification is+ -- successful, it will ensure that the resulting instance is well+ -- kinded. If not, the second constraint will result in an error+ -- message which points out the kind mismatch.+ -- See Note [Inferring the instance context]+ mk_functor_like_constraints orig t_or_k cls+ = map $ \ty -> let ki = typeKind ty in+ ( [ mk_cls_pred orig t_or_k cls ty+ , mkPredOrigin orig KindLevel+ (mkPrimEqPred ki typeToTypeKind) ]+ , tcUnifyTy ki typeToTypeKind+ ) - -- Stupid constraints- stupid_constraints = [ mkThetaOrigin DerivOrigin TypeLevel [] [] $- substTheta tc_subst (tyConStupidTheta rep_tc) ]- tc_subst = -- See the comment with all_rep_tc_args for an explanation of- -- this assertion- ASSERT( equalLength rep_tc_tvs all_rep_tc_args )- zipTvSubst rep_tc_tvs all_rep_tc_args+ rep_tc_tvs = tyConTyVars rep_tc+ last_tv = last rep_tc_tvs+ -- When we first gather up the constraints to solve, most of them+ -- contain rep_tc_tvs, i.e., the type variables from the derived+ -- datatype's type constructor. We don't want these type variables+ -- to appear in the final instance declaration, so we must+ -- substitute each type variable with its counterpart in the derived+ -- instance. rep_tc_args lists each of these counterpart types in+ -- the same order as the type variables.+ all_rep_tc_args+ = rep_tc_args ++ map mkTyVarTy+ (drop (length rep_tc_args) rep_tc_tvs) - -- Extra Data constraints- -- The Data class (only) requires that for- -- instance (...) => Data (T t1 t2)- -- IF t1:*, t2:*- -- THEN (Data t1, Data t2) are among the (...) constraints- -- Reason: when the IF holds, we generate a method- -- dataCast2 f = gcast2 f- -- and we need the Data constraints to typecheck the method- extra_constraints = [mkThetaOriginFromPreds constrs]- where- constrs- | main_cls `hasKey` dataClassKey- , all (isLiftedTypeKind . typeKind) rep_tc_args- = [ mk_cls_pred DerivOrigin t_or_k main_cls ty- | (t_or_k, ty) <- zip t_or_ks rep_tc_args]- | otherwise- = []+ -- Stupid constraints+ stupid_constraints+ = [ mkThetaOrigin DerivOrigin TypeLevel [] [] $+ substTheta tc_subst (tyConStupidTheta rep_tc) ]+ tc_subst = -- See the comment with all_rep_tc_args for an+ -- explanation of this assertion+ ASSERT( equalLength rep_tc_tvs all_rep_tc_args )+ zipTvSubst rep_tc_tvs all_rep_tc_args - mk_cls_pred orig t_or_k cls ty -- Don't forget to apply to cls_tys' too- = mkPredOrigin orig t_or_k (mkClassPred cls (cls_tys' ++ [ty]))- cls_tys' | is_generic1 = [] -- In the awkward Generic1 case, cls_tys'- -- should be empty, since we are applying the- -- class Functor.- | otherwise = cls_tys+ -- Extra Data constraints+ -- The Data class (only) requires that for+ -- instance (...) => Data (T t1 t2)+ -- IF t1:*, t2:*+ -- THEN (Data t1, Data t2) are among the (...) constraints+ -- Reason: when the IF holds, we generate a method+ -- dataCast2 f = gcast2 f+ -- and we need the Data constraints to typecheck the method+ extra_constraints = [mkThetaOriginFromPreds constrs]+ where+ constrs+ | main_cls `hasKey` dataClassKey+ , all (isLiftedTypeKind . typeKind) rep_tc_args+ = [ mk_cls_pred DerivOrigin t_or_k main_cls ty+ | (t_or_k, ty) <- zip t_or_ks rep_tc_args]+ | otherwise+ = [] + mk_cls_pred orig t_or_k cls ty+ -- Don't forget to apply to cls_tys' too+ = mkPredOrigin orig t_or_k (mkClassPred cls (cls_tys' ++ [ty]))+ cls_tys' | is_generic1 = []+ -- In the awkward Generic1 case, cls_tys' should be+ -- empty, since we are applying the class Functor.++ | otherwise = cls_tys++ if -- Generic constraints are easy+ | is_generic+ -> return ([], tvs, inst_tys)++ -- Generic1 needs Functor+ -- See Note [Getting base classes]+ | is_generic1+ -> ASSERT( rep_tc_tvs `lengthExceeds` 0 )+ -- Generic1 has a single kind variable+ ASSERT( cls_tys `lengthIs` 1 )+ do { functorClass <- lift $ tcLookupClass functorClassName+ ; pure $ con_arg_constraints+ $ get_gen1_constraints functorClass }++ -- The others are a bit more complicated+ | otherwise+ -> -- See the comment with all_rep_tc_args for an explanation of+ -- this assertion+ ASSERT2( equalLength rep_tc_tvs all_rep_tc_args+ , ppr main_cls <+> ppr rep_tc+ $$ ppr rep_tc_tvs $$ ppr all_rep_tc_args )+ do { let (arg_constraints, tvs', inst_tys')+ = con_arg_constraints get_std_constrained_tys+ ; lift $ traceTc "inferConstraintsDataConArgs" $ vcat+ [ ppr main_cls <+> ppr inst_tys'+ , ppr arg_constraints+ ]+ ; return ( stupid_constraints ++ extra_constraints+ ++ arg_constraints+ , tvs', inst_tys') }+ typeToTypeKind :: Kind typeToTypeKind = liftedTypeKind `mkFunTy` liftedTypeKind @@ -240,44 +288,50 @@ -- See Note [Gathering and simplifying constraints for DeriveAnyClass] -- for an explanation of how these constraints are used to determine the -- derived instance context.-inferConstraintsDAC :: Class -> [TyVar] -> [TcType]- -> TcM ([ThetaOrigin], [TyVar], [TcType])-inferConstraintsDAC cls tvs inst_tys- = do { let gen_dms = [ (sel_id, dm_ty)+inferConstraintsDAC :: [TcType] -> DerivM ([ThetaOrigin], [TyVar], [TcType])+inferConstraintsDAC inst_tys+ = do { DerivEnv { denv_tvs = tvs+ , denv_cls = cls } <- ask++ ; let gen_dms = [ (sel_id, dm_ty) | (sel_id, Just (_, GenericDM dm_ty)) <- classOpItems cls ] - ; theta_origins <- pushTcLevelM_ (mapM do_one_meth gen_dms)+ cls_tvs = classTyVars cls+ empty_subst = mkEmptyTCvSubst (mkInScopeSet (mkVarSet tvs))++ do_one_meth :: (Id, Type) -> TcM ThetaOrigin+ -- (Id,Type) are the selector Id and the generic default method type+ -- NB: the latter is /not/ quantified over the class variables+ -- See Note [Gathering and simplifying constraints for DeriveAnyClass]+ do_one_meth (sel_id, gen_dm_ty)+ = do { let (sel_tvs, _cls_pred, meth_ty)+ = tcSplitMethodTy (varType sel_id)+ meth_ty' = substTyWith sel_tvs inst_tys meth_ty+ (meth_tvs, meth_theta, meth_tau)+ = tcSplitNestedSigmaTys meth_ty'++ gen_dm_ty' = substTyWith cls_tvs inst_tys gen_dm_ty+ (dm_tvs, dm_theta, dm_tau)+ = tcSplitNestedSigmaTys gen_dm_ty'++ ; (subst, _meta_tvs) <- pushTcLevelM_ $+ newMetaTyVarsX empty_subst dm_tvs+ -- Yuk: the pushTcLevel is to match the one in mk_wanteds+ -- simplifyDeriv. If we don't, the unification+ -- variables will bogusly be untouchable.++ ; let dm_theta' = substTheta subst dm_theta+ tau_eq = mkPrimEqPred meth_tau (substTy subst dm_tau)+ ; return (mkThetaOrigin DerivOrigin TypeLevel+ meth_tvs meth_theta (tau_eq:dm_theta')) }++ ; theta_origins <- lift $ pushTcLevelM_ (mapM do_one_meth gen_dms) -- Yuk: the pushTcLevel is to match the one wrapping the call -- to mk_wanteds in simplifyDeriv. If we omit this, the -- unification variables will wrongly be untouchable. ; return (theta_origins, tvs, inst_tys) }- where- cls_tvs = classTyVars cls- empty_subst = mkEmptyTCvSubst (mkInScopeSet (mkVarSet tvs)) - do_one_meth :: (Id, Type) -> TcM ThetaOrigin- -- (Id,Type) are the selector Id and the generic default method type- -- NB: the latter is /not/ quantified over the class variables- -- See Note [Gathering and simplifying constraints for DeriveAnyClass]- do_one_meth (sel_id, gen_dm_ty)- = do { let (sel_tvs, _cls_pred, meth_ty) = tcSplitMethodTy (varType sel_id)- meth_ty' = substTyWith sel_tvs inst_tys meth_ty- (meth_tvs, meth_theta, meth_tau) = tcSplitNestedSigmaTys meth_ty'-- gen_dm_ty' = substTyWith cls_tvs inst_tys gen_dm_ty- (dm_tvs, dm_theta, dm_tau) = tcSplitNestedSigmaTys gen_dm_ty'-- ; (subst, _meta_tvs) <- pushTcLevelM_ $- newMetaTyVarsX empty_subst dm_tvs- -- Yuk: the pushTcLevel is to match the one in mk_wanteds- -- simplifyDeriv. If we don't, the unification variables- -- will bogusly be untouchable.- ; let dm_theta' = substTheta subst dm_theta- tau_eq = mkPrimEqPred meth_tau (substTy subst dm_tau)- ; return (mkThetaOrigin DerivOrigin TypeLevel- meth_tvs meth_theta (tau_eq:dm_theta')) }- {- Note [Inferring the instance context] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ There are two sorts of 'deriving':@@ -294,7 +348,7 @@ the instance context is user-supplied For a deriving clause (InferTheta) we must figure out the-instance context (inferConstraints). Suppose we are inferring+instance context (inferConstraintsDataConArgs). Suppose we are inferring the instance context for C t1 .. tn (T s1 .. sm) There are two cases@@ -404,7 +458,7 @@ Eq (T a b) = (Ping a, Pong b, ...) Now we can get a (recursive) equation from the data decl. This part-is done by inferConstraints.+is done by inferConstraintsDataConArgs. Eq (T a b) = Eq (Foo a) u Eq (Bar b) -- From C1 u Eq (T b a) u Eq Int -- From C2@@ -650,7 +704,7 @@ vcat [ ppr tvs_skols, ppr residual_simple, ppr good, ppr bad ] -- Return the good unsolved constraints (unskolemizing on the way out.)- ; let min_theta = mkMinimalBySCs (bagToList good)+ ; let min_theta = mkMinimalBySCs id (bagToList good) -- An important property of mkMinimalBySCs (used above) is that in -- addition to removing constraints that are made redundant by -- superclass relationships, it also removes _duplicate_@@ -762,7 +816,7 @@ ~ Maybe s -> Maybe s -> Bool) In this case baz has no local quantification, so the implication-constraint has no local skolems and there are no unificaiton+constraint has no local skolems and there are no unification variables. [STEP DAC SOLVE]
typecheck/TcDerivUtils.hs view
@@ -6,9 +6,10 @@ Error-checking and other utilities for @deriving@ clauses or declarations. -} -{-# LANGUAGE ImplicitParams #-}+{-# LANGUAGE TypeFamilies #-} module TcDerivUtils (+ DerivM, DerivEnv(..), DerivSpec(..), pprDerivSpec, DerivSpecMechanism(..), isDerivSpecStock, isDerivSpecNewtype, isDerivSpecAnyClass,@@ -21,6 +22,8 @@ newDerivClsInst, extendLocalInstEnv ) where +import GhcPrelude+ import Bag import BasicTypes import Class@@ -36,7 +39,6 @@ import Name import Outputable import PrelNames-import RdrName import SrcLoc import TcGenDeriv import TcGenFunctor@@ -49,9 +51,68 @@ import Util import VarSet +import Control.Monad.Trans.Reader import qualified GHC.LanguageExtensions as LangExt import ListSetOps (assocMaybe) +-- | To avoid having to manually plumb everything in 'DerivEnv' throughout+-- various functions in @TcDeriv@ and @TcDerivInfer@, we use 'DerivM', which+-- is a simple reader around 'TcRn'.+type DerivM = ReaderT DerivEnv TcRn++-- | Contains all of the information known about a derived instance when+-- determining what its @EarlyDerivSpec@ should be.+data DerivEnv = DerivEnv+ { denv_overlap_mode :: Maybe OverlapMode+ -- ^ Is this an overlapping instance?+ , denv_tvs :: [TyVar]+ -- ^ Universally quantified type variables in the instance+ , denv_cls :: Class+ -- ^ Class for which we need to derive an instance+ , denv_cls_tys :: [Type]+ -- ^ Other arguments to the class except the last+ , denv_tc :: TyCon+ -- ^ Type constructor for which the instance is requested+ -- (last arguments to the type class)+ , denv_tc_args :: [Type]+ -- ^ Arguments to the type constructor+ , denv_rep_tc :: TyCon+ -- ^ The representation tycon for 'denv_tc'+ -- (for data family instances)+ , denv_rep_tc_args :: [Type]+ -- ^ The representation types for 'denv_tc_args'+ -- (for data family instances)+ , denv_mtheta :: DerivContext+ -- ^ 'Just' the context of the instance, for standalone deriving.+ -- 'Nothing' for @deriving@ clauses.+ , denv_strat :: Maybe DerivStrategy+ -- ^ 'Just' if user requests a particular deriving strategy.+ -- Otherwise, 'Nothing'.+ }++instance Outputable DerivEnv where+ ppr (DerivEnv { denv_overlap_mode = overlap_mode+ , denv_tvs = tvs+ , denv_cls = cls+ , denv_cls_tys = cls_tys+ , denv_tc = tc+ , denv_tc_args = tc_args+ , denv_rep_tc = rep_tc+ , denv_rep_tc_args = rep_tc_args+ , denv_mtheta = mtheta+ , denv_strat = mb_strat })+ = hang (text "DerivEnv")+ 2 (vcat [ text "denv_overlap_mode" <+> ppr overlap_mode+ , text "denv_tvs" <+> ppr tvs+ , text "denv_cls" <+> ppr cls+ , text "denv_cls_tys" <+> ppr cls_tys+ , text "denv_tc" <+> ppr tc+ , text "denv_tc_args" <+> ppr tc_args+ , text "denv_rep_tc" <+> ppr rep_tc+ , text "denv_rep_tc_args" <+> ppr rep_tc_args+ , text "denv_mtheta" <+> ppr mtheta+ , text "denv_strat" <+> ppr mb_strat ])+ data DerivSpec theta = DS { ds_loc :: SrcSpan , ds_name :: Name -- DFun name , ds_tvs :: [TyVar]@@ -105,13 +166,27 @@ -- What action to take in order to derive a class instance. -- See Note [Deriving strategies] in TcDeriv--- NB: DerivSpecMechanism is purely local to this module data DerivSpecMechanism = DerivSpecStock -- "Standard" classes- (SrcSpan -> TyCon -> [Type] -> TcM (LHsBinds RdrName, BagDerivStuff))+ (SrcSpan -> TyCon+ -> [Type]+ -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))+ -- This function returns three things:+ --+ -- 1. @LHsBinds GhcPs@: The derived instance's function bindings+ -- (e.g., @compare (T x) (T y) = compare x y@)+ -- 2. @BagDerivStuff@: Auxiliary bindings needed to support the derived+ -- instance. As examples, derived 'Generic' instances require+ -- associated type family instances, and derived 'Eq' and 'Ord'+ -- instances require top-level @con2tag@ functions.+ -- See Note [Auxiliary binders] in TcGenDeriv.+ -- 3. @[Name]@: A list of Names for which @-Wunused-binds@ should be+ -- suppressed. This is used to suppress unused warnings for record+ -- selectors when deriving 'Read', 'Show', or 'Generic'.+ -- See Note [Deriving and unused record selectors]. | DerivSpecNewtype -- -XGeneralizedNewtypeDeriving- Type -- ^ The newtype rep type+ Type -- The newtype rep type | DerivSpecAnyClass -- -XDeriveAnyClass @@ -236,25 +311,26 @@ case. -} -hasStockDeriving :: Class- -> Maybe (SrcSpan- -> TyCon- -> [Type]- -> TcM (LHsBinds RdrName, BagDerivStuff))+hasStockDeriving+ :: Class -> Maybe (SrcSpan+ -> TyCon+ -> [Type]+ -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name])) hasStockDeriving clas = assocMaybe gen_list (getUnique clas) where- gen_list :: [(Unique, SrcSpan- -> TyCon- -> [Type]- -> TcM (LHsBinds RdrName, BagDerivStuff))]+ gen_list+ :: [(Unique, SrcSpan+ -> TyCon+ -> [Type]+ -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))] gen_list = [ (eqClassKey, simpleM gen_Eq_binds) , (ordClassKey, simpleM gen_Ord_binds) , (enumClassKey, simpleM gen_Enum_binds) , (boundedClassKey, simple gen_Bounded_binds) , (ixClassKey, simpleM gen_Ix_binds)- , (showClassKey, with_fix_env gen_Show_binds)- , (readClassKey, with_fix_env gen_Read_binds)+ , (showClassKey, read_or_show gen_Show_binds)+ , (readClassKey, read_or_show gen_Read_binds) , (dataClassKey, simpleM gen_Data_binds) , (functorClassKey, simple gen_Functor_binds) , (foldableClassKey, simple gen_Foldable_binds)@@ -264,19 +340,58 @@ , (gen1ClassKey, generic (gen_Generic_binds Gen1)) ] simple gen_fn loc tc _- = return (gen_fn loc tc)+ = let (binds, deriv_stuff) = gen_fn loc tc+ in return (binds, deriv_stuff, []) simpleM gen_fn loc tc _- = gen_fn loc tc+ = do { (binds, deriv_stuff) <- gen_fn loc tc+ ; return (binds, deriv_stuff, []) } - with_fix_env gen_fn loc tc _+ read_or_show gen_fn loc tc _ = do { fix_env <- getDataConFixityFun tc- ; return (gen_fn fix_env loc tc) }+ ; let (binds, deriv_stuff) = gen_fn fix_env loc tc+ field_names = all_field_names tc+ ; return (binds, deriv_stuff, field_names) } generic gen_fn _ tc inst_tys = do { (binds, faminst) <- gen_fn tc inst_tys- ; return (binds, unitBag (DerivFamInst faminst)) }+ ; let field_names = all_field_names tc+ ; return (binds, unitBag (DerivFamInst faminst), field_names) } + -- See Note [Deriving and unused record selectors]+ all_field_names = map flSelector . concatMap dataConFieldLabels+ . tyConDataCons++{-+Note [Deriving and unused record selectors]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this (see Trac #13919):++ module Main (main) where++ data Foo = MkFoo {bar :: String} deriving Show++ main :: IO ()+ main = print (Foo "hello")++Strictly speaking, the record selector `bar` is unused in this module, since+neither `main` nor the derived `Show` instance for `Foo` mention `bar`.+However, the behavior of `main` is affected by the presence of `bar`, since+it will print different output depending on whether `MkFoo` is defined using+record selectors or not. Therefore, we do not to issue a+"Defined but not used: ‘bar’" warning for this module, since removing `bar`+changes the program's behavior. This is the reason behind the [Name] part of+the return type of `hasStockDeriving`—it tracks all of the record selector+`Name`s for which -Wunused-binds should be suppressed.++Currently, the only three stock derived classes that require this are Read,+Show, and Generic, as their derived code all depend on the record selectors+of the derived data type's constructors.++See also Note [Newtype deriving and unused constructors] in TcDeriv for+another example of a similar trick.+-}+ getDataConFixityFun :: TyCon -> TcM (Name -> Fixity) -- If the TyCon is locally defined, we want the local fixity env; -- but if it is imported (which happens for standalone deriving)@@ -343,7 +458,7 @@ | cls_key == ixClassKey = Just (cond_std `andCond` cond_enumOrProduct cls) | cls_key == boundedClassKey = Just (cond_std `andCond` cond_enumOrProduct cls) | cls_key == dataClassKey = Just (checkFlag LangExt.DeriveDataTypeable `andCond`- cond_std `andCond`+ cond_vanilla `andCond` cond_args cls) | cls_key == functorClassKey = Just (checkFlag LangExt.DeriveFunctor `andCond` cond_vanilla `andCond`@@ -406,13 +521,18 @@ = IsValid -- Don't check these conservative conditions for -- standalone deriving; just generate the code -- and let the typechecker handle the result-cond_stdOK Nothing permissive _ rep_tc+cond_stdOK Nothing permissive dflags rep_tc | null data_cons- , not permissive = NotValid (no_cons_why rep_tc $$ suggestion)- | not (null con_whys) = NotValid (vcat con_whys $$ suggestion)+ , not permissive = checkFlag LangExt.EmptyDataDeriving dflags rep_tc+ `orValid`+ NotValid (no_cons_why rep_tc $$ empty_data_suggestion)+ | not (null con_whys) = NotValid (vcat con_whys $$ standalone_suggestion) | otherwise = IsValid where- suggestion = text "Possible fix: use a standalone deriving declaration instead"+ empty_data_suggestion =+ text "Use EmptyDataDeriving to enable deriving for empty data types"+ standalone_suggestion =+ text "Possible fix: use a standalone deriving declaration instead" data_cons = tyConDataCons rep_tc con_whys = getInvalids (map check_con data_cons) @@ -512,7 +632,8 @@ tc_tvs = tyConTyVars rep_tc Just (_, last_tv) = snocView tc_tvs bad_stupid_theta = filter is_bad (tyConStupidTheta rep_tc)- is_bad pred = last_tv `elemVarSet` tyCoVarsOfType pred+ is_bad pred = last_tv `elemVarSet` exactTyCoVarsOfType pred+ -- See Note [Check that the type variable is truly universal] data_cons = tyConDataCons rep_tc check_con con = allValid (check_universal con : foldDataConArgs (ft_check con) con)@@ -524,7 +645,7 @@ -- in TcGenFunctor | Just tv <- getTyVar_maybe (last (tyConAppArgs (dataConOrigResTy con))) , tv `elem` dataConUnivTyVars con- , not (tv `elemVarSet` tyCoVarsOfTypes (dataConTheta con))+ , not (tv `elemVarSet` exactTyCoVarsOfTypes (dataConTheta con)) = IsValid -- See Note [Check that the type variable is truly universal] | otherwise = NotValid (badCon con existential)@@ -666,4 +787,17 @@ foldr _ z T6 = z See Note [DeriveFoldable with ExistentialQuantification] in TcGenFunctor.++For Functor and Traversable, we must take care not to let type synonyms+unfairly reject a type for not being truly universally quantified. An+example of this is:++ type C (a :: Constraint) b = a+ data T a b = C (Show a) b => MkT b++Here, the existential context (C (Show a) b) does technically mention the last+type variable b. But this is OK, because expanding the type synonym C would+give us the context (Show a), which doesn't mention b. Therefore, we must make+sure to expand type synonyms before performing this check. Not doing so led to+Trac #13813. -}
typecheck/TcEnv.hs view
@@ -30,11 +30,11 @@ tcExtendTyVarEnv, tcExtendTyVarEnv2, tcExtendLetEnv, tcExtendSigIds, tcExtendRecIds, tcExtendIdEnv, tcExtendIdEnv1, tcExtendIdEnv2,- tcExtendIdBndrs, tcExtendLocalTypeEnv,+ tcExtendBinderStack, tcExtendLocalTypeEnv, isTypeClosedLetBndr, tcLookup, tcLookupLocated, tcLookupLocalIds,- tcLookupId, tcLookupTyVar,+ tcLookupId, tcLookupIdMaybe, tcLookupTyVar, tcLookupLcl_maybe, getInLocalScope, wrongThingErr, pprBinders,@@ -43,6 +43,9 @@ getTypeSigNames, tcExtendRecEnv, -- For knot-tying + -- Tidying+ tcInitTidyEnv, tcInitOpenTidyEnv,+ -- Instances tcLookupInstance, tcGetInstEnvs, @@ -68,6 +71,8 @@ #include "HsVersions.h" +import GhcPrelude+ import HsSyn import IfaceEnv import TcRnMonad@@ -85,6 +90,7 @@ import PatSyn ( PatSyn ) import ConLike import TyCon+import Type import CoAxiom import Class import Name@@ -346,12 +352,19 @@ -- -- The Id is never a DataCon. (Why does that matter? see TcExpr.tcId) tcLookupId name = do- thing <- tcLookup name+ thing <- tcLookupIdMaybe name case thing of- ATcId { tct_id = id} -> return id- AGlobal (AnId id) -> return id- _ -> pprPanic "tcLookupId" (ppr name)+ Just id -> return id+ _ -> pprPanic "tcLookupId" (ppr name) +tcLookupIdMaybe :: Name -> TcM (Maybe Id)+tcLookupIdMaybe name+ = do { thing <- tcLookup name+ ; case thing of+ ATcId { tct_id = id} -> return $ Just id+ AGlobal (AnId id) -> return $ Just id+ _ -> return Nothing }+ tcLookupLocalIds :: [Name] -> TcM [TcId] -- We expect the variables to all be bound, and all at -- the same level as the lookup. Only used in one place...@@ -398,23 +411,11 @@ -- thus, no coercion variables = do { tc_extend_local_env NotTopLevel [(name, ATyVar name tv) | (name, tv) <- binds] $- do { env <- getLclEnv- ; let env' = env { tcl_tidy = add_tidy_tvs (tcl_tidy env) }- ; setLclEnv env' thing_inside }}+ tcExtendBinderStack tv_binds $+ thing_inside } where- add_tidy_tvs env = foldl add env binds-- -- We initialise the "tidy-env", used for tidying types before printing,- -- by building a reverse map from the in-scope type variables to the- -- OccName that the programmer originally used for them- add :: TidyEnv -> (Name, TcTyVar) -> TidyEnv- add (env,subst) (name, tyvar)- = ASSERT( isTyVar tyvar )- case tidyOccName env (nameOccName name) of- (env', occ') -> (env', extendVarEnv subst tyvar tyvar')- where- tyvar' = setTyVarName tyvar name'- name' = tidyNameOcc name occ'+ tv_binds :: [TcBinder]+ tv_binds = [TcTvBndr name tv | (name,tv) <- binds] isTypeClosedLetBndr :: Id -> Bool -- See Note [Bindings with closed types] in TcRnTypes@@ -423,7 +424,7 @@ tcExtendRecIds :: [(Name, TcId)] -> TcM a -> TcM a -- Used for binding the recurive uses of Ids in a binding -- both top-level value bindings and and nested let/where-bindings--- Does not extend the TcIdBinderStack+-- Does not extend the TcBinderStack tcExtendRecIds pairs thing_inside = tc_extend_local_env NotTopLevel [ (name, ATcId { tct_id = let_id@@ -433,7 +434,7 @@ tcExtendSigIds :: TopLevelFlag -> [TcId] -> TcM a -> TcM a -- Used for binding the Ids that have a complete user type signature--- Does not extend the TcIdBinderStack+-- Does not extend the TcBinderStack tcExtendSigIds top_lvl sig_ids thing_inside = tc_extend_local_env top_lvl [ (idName id, ATcId { tct_id = id@@ -447,10 +448,10 @@ tcExtendLetEnv :: TopLevelFlag -> TcSigFun -> IsGroupClosed -> [TcId] -> TcM a -> TcM a -- Used for both top-level value bindings and and nested let/where-bindings--- Adds to the TcIdBinderStack too+-- Adds to the TcBinderStack too tcExtendLetEnv top_lvl sig_fn (IsGroupClosed fvs fv_type_closed) ids thing_inside- = tcExtendIdBndrs [TcIdBndr id top_lvl | id <- ids] $+ = tcExtendBinderStack [TcIdBndr id top_lvl | id <- ids] $ tc_extend_local_env top_lvl [ (idName id, ATcId { tct_id = id , tct_info = mk_tct_info id })@@ -468,7 +469,7 @@ tcExtendIdEnv :: [TcId] -> TcM a -> TcM a -- For lambda-bound and case-bound Ids--- Extends the the TcIdBinderStack as well+-- Extends the the TcBinderStack as well tcExtendIdEnv ids thing_inside = tcExtendIdEnv2 [(idName id, id) | id <- ids] thing_inside @@ -479,8 +480,8 @@ tcExtendIdEnv2 :: [(Name,TcId)] -> TcM a -> TcM a tcExtendIdEnv2 names_w_ids thing_inside- = tcExtendIdBndrs [ TcIdBndr mono_id NotTopLevel- | (_,mono_id) <- names_w_ids ] $+ = tcExtendBinderStack [ TcIdBndr mono_id NotTopLevel+ | (_,mono_id) <- names_w_ids ] $ tc_extend_local_env NotTopLevel [ (name, ATcId { tct_id = id , tct_info = NotLetBound })@@ -536,11 +537,17 @@ get_tvs (_, ATcId { tct_id = id, tct_info = closed }) tvs = case closed of- ClosedLet ->- ASSERT2( isEmptyVarSet id_tvs, ppr id $$ ppr (idType id) ) tvs- _ ->- tvs `unionVarSet` id_tvs- where id_tvs = tyCoVarsOfType (idType id)+ ClosedLet -> ASSERT2( is_closed_type, ppr id $$ ppr (idType id) )+ tvs+ _other -> tvs `unionVarSet` id_tvs+ where+ id_tvs = tyCoVarsOfType (idType id)+ is_closed_type = not (anyVarSet isTyVar id_tvs)+ -- We only care about being closed wrt /type/ variables+ -- E.g. a top-level binding might have a type like+ -- foo :: t |> co+ -- where co :: * ~ *+ -- or some other as-yet-unsolved kind coercion get_tvs (_, ATyVar _ tv) tvs -- See Note [Global TyVars] = tvs `unionVarSet` tyCoVarsOfType (tyVarKind tv) `extendVarSet` tv@@ -560,23 +567,59 @@ -- -- Nor must we generalise g over any kind variables free in r's kind ----------------------------------------------------------------- Extending the TcIdBinderStack, used only for error messages -tcExtendIdBndrs :: [TcIdBinder] -> TcM a -> TcM a-tcExtendIdBndrs bndrs thing_inside- = do { traceTc "tcExtendIdBndrs" (ppr bndrs)+{- *********************************************************************+* *+ The TcBinderStack+* *+********************************************************************* -}++tcExtendBinderStack :: [TcBinder] -> TcM a -> TcM a+tcExtendBinderStack bndrs thing_inside+ = do { traceTc "tcExtendBinderStack" (ppr bndrs) ; updLclEnv (\env -> env { tcl_bndrs = bndrs ++ tcl_bndrs env }) thing_inside } +tcInitTidyEnv :: TcM TidyEnv+-- We initialise the "tidy-env", used for tidying types before printing,+-- by building a reverse map from the in-scope type variables to the+-- OccName that the programmer originally used for them+tcInitTidyEnv+ = do { lcl_env <- getLclEnv+ ; go emptyTidyEnv (tcl_bndrs lcl_env) }+ where+ go (env, subst) []+ = return (env, subst)+ go (env, subst) (b : bs)+ | TcTvBndr name tyvar <- b+ = do { let (env', occ') = tidyOccName env (nameOccName name)+ name' = tidyNameOcc name occ'+ tyvar1 = setTyVarName tyvar name'+ ; tyvar2 <- zonkTcTyVarToTyVar tyvar1+ -- Be sure to zonk here! Tidying applies to zonked+ -- types, so if we don't zonk we may create an+ -- ill-kinded type (Trac #14175)+ ; go (env', extendVarEnv subst tyvar tyvar2) bs }+ | otherwise+ = go (env, subst) bs +-- | Get a 'TidyEnv' that includes mappings for all vars free in the given+-- type. Useful when tidying open types.+tcInitOpenTidyEnv :: [TyCoVar] -> TcM TidyEnv+tcInitOpenTidyEnv tvs+ = do { env1 <- tcInitTidyEnv+ ; let env2 = tidyFreeTyCoVars env1 tvs+ ; return env2 }+++ {- ********************************************************************* * * Adding placeholders * * ********************************************************************* -} -tcAddDataFamConPlaceholders :: [LInstDecl Name] -> TcM a -> TcM a+tcAddDataFamConPlaceholders :: [LInstDecl GhcRn] -> TcM a -> TcM a -- See Note [AFamDataCon: not promoting data family constructors] tcAddDataFamConPlaceholders inst_decls thing_inside = tcExtendKindEnvList [ (con, APromotionErr FamDataConPE)@@ -585,30 +628,31 @@ -- Note [AFamDataCon: not promoting data family constructors] where -- get_cons extracts the *constructor* bindings of the declaration- get_cons :: LInstDecl Name -> [Name]+ get_cons :: LInstDecl GhcRn -> [Name] get_cons (L _ (TyFamInstD {})) = [] get_cons (L _ (DataFamInstD { dfid_inst = fid })) = get_fi_cons fid get_cons (L _ (ClsInstD { cid_inst = ClsInstDecl { cid_datafam_insts = fids } })) = concatMap (get_fi_cons . unLoc) fids - get_fi_cons :: DataFamInstDecl Name -> [Name]- get_fi_cons (DataFamInstDecl { dfid_defn = HsDataDefn { dd_cons = cons } })+ get_fi_cons :: DataFamInstDecl GhcRn -> [Name]+ get_fi_cons (DataFamInstDecl { dfid_eqn = HsIB { hsib_body =+ FamEqn { feqn_rhs = HsDataDefn { dd_cons = cons } }}}) = map unLoc $ concatMap (getConNames . unLoc) cons -tcAddPatSynPlaceholders :: [PatSynBind Name Name] -> TcM a -> TcM a+tcAddPatSynPlaceholders :: [PatSynBind GhcRn GhcRn] -> TcM a -> TcM a -- See Note [Don't promote pattern synonyms] tcAddPatSynPlaceholders pat_syns thing_inside = tcExtendKindEnvList [ (name, APromotionErr PatSynPE) | PSB{ psb_id = L _ name } <- pat_syns ] thing_inside -getTypeSigNames :: [LSig Name] -> NameSet+getTypeSigNames :: [LSig GhcRn] -> NameSet -- Get the names that have a user type sig getTypeSigNames sigs = foldr get_type_sig emptyNameSet sigs where- get_type_sig :: LSig Name -> NameSet -> NameSet+ get_type_sig :: LSig GhcRn -> NameSet -> NameSet get_type_sig sig ns = case sig of L _ (TypeSig names _) -> extendNameSetList ns (map unLoc names)@@ -672,7 +716,7 @@ ************************************************************************ -} -tcExtendRules :: [LRuleDecl Id] -> TcM a -> TcM a+tcExtendRules :: [LRuleDecl GhcTc] -> TcM a -> TcM a -- Just pop the new rules into the EPS and envt resp -- All the rules come from an interface file, not source -- Nevertheless, some may be for this module, if we read@@ -791,7 +835,7 @@ and then GHCi doesn't attempt to print the (). So in interactive mode, we add () to the list of defaulting types. See Trac #1200. -Additonally, the list type [] is added as a default specialization for+Additionally, the list type [] is added as a default specialization for Traversable and Foldable. As such the default default list now has types of varying kinds, e.g. ([] :: * -> *) and (Integer :: *). @@ -846,10 +890,10 @@ -- Used only to improve error messages } -instance (OutputableBndrId a) => Outputable (InstInfo a) where+instance (SourceTextX a, OutputableBndrId a) => Outputable (InstInfo a) where ppr = pprInstInfoDetails -pprInstInfoDetails :: (OutputableBndrId a) => InstInfo a -> SDoc+pprInstInfoDetails :: (SourceTextX a, OutputableBndrId a) => InstInfo a -> SDoc pprInstInfoDetails info = hang (pprInstanceHdr (iSpec info) <+> text "where") 2 (details (iBinds info))
typecheck/TcEnv.hs-boot view
@@ -1,6 +1,10 @@-{-->module TcEnv where->import TcRnTypes->->tcExtendIdEnv :: [TcId] -> TcM a -> TcM a--}+module TcEnv where++import TcRnTypes( TcM )+import VarEnv( TidyEnv )++-- Annoyingly, there's a recursion between tcInitTidyEnv+-- (which does zonking and hence needs TcMType) and+-- addErrTc etc which live in TcRnMonad. Rats.+tcInitTidyEnv :: TcM TidyEnv+
typecheck/TcErrors.hs view
@@ -9,12 +9,15 @@ #include "HsVersions.h" +import GhcPrelude+ import TcRnTypes import TcRnMonad import TcMType import TcUnify( occCheckForErrors, OccCheckResult(..) )+import TcEnv( tcInitTidyEnv ) import TcType-import RnEnv( unknownNameSuggestions )+import RnUnbound ( unknownNameSuggestions ) import Type import TyCoRep import Kind@@ -32,7 +35,8 @@ import HsBinds ( PatSynBind(..) ) import Name import RdrName ( lookupGlobalRdrEnv, lookupGRE_Name, GlobalRdrEnv- , mkRdrUnqual, isLocalGRE, greSrcSpan )+ , mkRdrUnqual, isLocalGRE, greSrcSpan, pprNameProvenance+ , GlobalRdrElt (..), globalRdrEnvElts ) import PrelNames ( typeableClassName, hasKey, liftedRepDataConKey ) import Id import Var@@ -42,25 +46,27 @@ import Bag import ErrUtils ( ErrMsg, errDoc, pprLocErrMsg ) import BasicTypes-import ConLike ( ConLike(..) )+import ConLike ( ConLike(..)) import Util+import TcEnv (tcLookup)+import {-# SOURCE #-} TcSimplify ( tcCheckHoleFit ) import FastString import Outputable import SrcLoc import DynFlags import ListSetOps ( equivClasses ) import Maybes+import Pair import qualified GHC.LanguageExtensions as LangExt-import FV ( fvVarList, unionFV )+import FV ( fvVarList, fvVarSet, unionFV ) import Control.Monad ( when )-import Data.List ( partition, mapAccumL, nub, sortBy, unfoldr )+import Data.Foldable ( toList )+import Data.List ( partition, mapAccumL, nub, sortBy, unfoldr, foldl') import qualified Data.Set as Set -#if __GLASGOW_HASKELL__ > 710 import Data.Semigroup ( Semigroup ) import qualified Data.Semigroup as Semigroup-#endif {-@@ -193,6 +199,7 @@ ; traceTc "reportUnsolved (after zonking):" $ vcat [ text "Free tyvars:" <+> pprTyVars free_tvs+ , text "Tidy env:" <+> ppr tidy_env , text "Wanted:" <+> ppr wanted ] ; warn_redundant <- woptM Opt_WarnRedundantConstraints@@ -219,12 +226,16 @@ data Report = Report { report_important :: [SDoc] , report_relevant_bindings :: [SDoc]+ , report_valid_substitutions :: [SDoc] } instance Outputable Report where -- Debugging only- ppr (Report { report_important = imp, report_relevant_bindings = rel })+ ppr (Report { report_important = imp+ , report_relevant_bindings = rel+ , report_valid_substitutions = val }) = vcat [ text "important:" <+> vcat imp- , text "relevant:" <+> vcat rel ]+ , text "relevant:" <+> vcat rel+ , text "valid:" <+> vcat val ] {- Note [Error report] The idea is that error msgs are divided into three parts: the main msg, the@@ -239,14 +250,12 @@ multiple places so they have to be in the Report. -} -#if __GLASGOW_HASKELL__ > 710 instance Semigroup Report where- Report a1 b1 <> Report a2 b2 = Report (a1 ++ a2) (b1 ++ b2)-#endif+ Report a1 b1 c1 <> Report a2 b2 c2 = Report (a1 ++ a2) (b1 ++ b2) (c1 ++ c2) instance Monoid Report where- mempty = Report [] []- mappend (Report a1 b1) (Report a2 b2) = Report (a1 ++ a2) (b1 ++ b2)+ mempty = Report [] [] []+ mappend = (Semigroup.<>) -- | Put a doc into the important msgs block. important :: SDoc -> Report@@ -256,6 +265,10 @@ relevant_bindings :: SDoc -> Report relevant_bindings doc = mempty { report_relevant_bindings = [doc] } +-- | Put a doc into the valid substitutions block.+valid_substitutions :: SDoc -> Report+valid_substitutions docs = mempty { report_valid_substitutions = [docs] }+ data TypeErrorChoice -- What to do for type errors found by the type checker = TypeError -- A type error aborts compilation with an error message | TypeWarn -- A type error is deferred to runtime, plus a compile-time warning@@ -418,7 +431,7 @@ instance Add Zero b b instance Add a b ab => Add (Succ a) b (Succ ab) The context (Add a b ab) for the instance is clearly unused in terms-of evidence, since the dictionary has no feilds. But it is still+of evidence, since the dictionary has no fields. But it is still needed! With the context, a wanted constraint Add (Succ Zero) beta (Succ Zero) we will reduce to (Add Zero beta Zero), and thence we get beta := Zero.@@ -428,11 +441,10 @@ -} reportWanteds :: ReportErrCtxt -> TcLevel -> WantedConstraints -> TcM ()-reportWanteds ctxt tc_lvl (WC { wc_simple = simples, wc_insol = insols, wc_impl = implics })+reportWanteds ctxt tc_lvl (WC { wc_simple = simples, wc_impl = implics }) = do { traceTc "reportWanteds" (vcat [ text "Simples =" <+> ppr simples- , text "Insols =" <+> ppr insols , text "Suppress =" <+> ppr (cec_suppress ctxt)])- ; let tidy_cts = bagToList (mapBag (tidyCt env) (insols `unionBags` simples))+ ; traceTc "rw2" (ppr tidy_cts) -- First deal with things that are utterly wrong -- Like Int ~ Bool (incl nullary TyCons)@@ -459,26 +471,30 @@ -- if there's a *given* insoluble here (= inaccessible code) where env = cec_tidy ctxt+ tidy_cts = bagToList (mapBag (tidyCt env) simples) -- report1: ones that should *not* be suppresed by -- an insoluble somewhere else in the tree -- It's crucial that anything that is considered insoluble- -- (see TcRnTypes.trulyInsoluble) is caught here, otherwise+ -- (see TcRnTypes.insolubleWantedCt) is caught here, otherwise -- we might suppress its error message, and proceed on past -- type checking to get a Lint error later- report1 = [ ("custom_error", is_user_type_error,- True, mkUserTypeErrorReporter)+ report1 = [ ("custom_error", is_user_type_error,True, mkUserTypeErrorReporter) , given_eq_spec- , ("insoluble2", utterly_wrong, True, mkGroupReporter mkEqErr)- , ("skolem eq1", very_wrong, True, mkSkolReporter)- , ("skolem eq2", skolem_eq, True, mkSkolReporter)- , ("non-tv eq", non_tv_eq, True, mkSkolReporter)- , ("Out of scope", is_out_of_scope, True, mkHoleReporter)- , ("Holes", is_hole, False, mkHoleReporter)+ , ("insoluble2", utterly_wrong, True, mkGroupReporter mkEqErr)+ , ("skolem eq1", very_wrong, True, mkSkolReporter)+ , ("skolem eq2", skolem_eq, True, mkSkolReporter)+ , ("non-tv eq", non_tv_eq, True, mkSkolReporter)+ , ("Out of scope", is_out_of_scope,True, mkHoleReporter tidy_cts)+ , ("Holes", is_hole, False, mkHoleReporter tidy_cts) -- The only remaining equalities are alpha ~ ty, -- where alpha is untouchable; and representational equalities- , ("Other eqs", is_equality, False, mkGroupReporter mkEqErr) ]+ -- Prefer homogeneous equalities over hetero, because the+ -- former might be holding up the latter.+ -- See Note [Equalities with incompatible kinds] in TcCanonical+ , ("Homo eqs", is_homo_equality, True, mkGroupReporter mkEqErr)+ , ("Other eqs", is_equality, False, mkGroupReporter mkEqErr) ] -- report2: we suppress these if there are insolubles elsewhere in the tree report2 = [ ("Implicit params", is_ip, False, mkGroupReporter mkIPErr)@@ -515,6 +531,9 @@ is_user_type_error ct _ = isUserTypeErrorCt ct + is_homo_equality _ (EqPred _ ty1 ty2) = typeKind ty1 `tcEqType` typeKind ty2+ is_homo_equality _ _ = False+ is_equality _ (EqPred {}) = True is_equality _ _ = False @@ -589,10 +608,10 @@ | eq_lhs_type ct1 ct2 = True | otherwise = False -mkHoleReporter :: Reporter+mkHoleReporter :: [Ct] -> Reporter -- Reports errors one at a time-mkHoleReporter ctxt- = mapM_ $ \ct -> do { err <- mkHoleError ctxt ct+mkHoleReporter tidy_simples ctxt+ = mapM_ $ \ct -> do { err <- mkHoleError tidy_simples ctxt ct ; maybeReportHoleError ctxt ct err ; maybeAddDeferredHoleBinding ctxt err ct } @@ -628,7 +647,7 @@ ; err <- mkEqErr_help dflags ctxt report ct' Nothing ty1 ty2 - ; traceTc "mkGivenErrorRporter" (ppr ct)+ ; traceTc "mkGivenErrorReporter" (ppr ct) ; maybeReportError ctxt err } where (ct : _ ) = cts -- Never empty@@ -636,9 +655,9 @@ ignoreErrorReporter :: Reporter -- Discard Given errors that don't come from--- a pattern match; maybe we should warn instead?ignoreErrorReporter ctxt cts+-- a pattern match; maybe we should warn instead? ignoreErrorReporter ctxt cts- = do { traceTc "mkGivenErrorRporter no" (ppr cts $$ ppr (cec_encl ctxt))+ = do { traceTc "mkGivenErrorReporter no" (ppr cts $$ ppr (cec_encl ctxt)) ; return () } @@ -663,15 +682,15 @@ will have a Given constraint [G] Int ~ Bool. But we don't want to report ALL insoluble Given constraints. See Trac-#12466 for a long discussion on. For example, if we aren't careful+#12466 for a long discussion. For example, if we aren't careful we'll complain about f :: ((Int ~ Bool) => a -> a) -> Int which arguably is OK. It's more debatable for g :: (Int ~ Bool) => Int -> Int-but it's tricky to distinguish these cases to we don't report+but it's tricky to distinguish these cases so we don't report either. -The bottom line is this: find_gadt_match looks for an encosing+The bottom line is this: find_gadt_match looks for an enclosing pattern match which binds some equality constraints. If we find one, we report the insoluble Given. -}@@ -682,7 +701,7 @@ -- Group together errors from same location, -- and report only the first (to avoid a cascade) mkGroupReporter mk_err ctxt cts- = mapM_ (reportGroup mk_err ctxt) (equivClasses cmp_loc cts)+ = mapM_ (reportGroup mk_err ctxt . toList) (equivClasses cmp_loc cts) eq_lhs_type :: Ct -> Ct -> Bool eq_lhs_type ct1 ct2@@ -786,9 +805,9 @@ -> addTcEvBind ev_binds_var $ mkWantedEvBind evar err_tm HoleDest hole -> do { -- See Note [Deferred errors for coercion holes]- evar <- newEvVar pred- ; addTcEvBind ev_binds_var $ mkWantedEvBind evar err_tm- ; fillCoercionHole hole (mkTcCoVarCo evar) }}+ let co_var = coHoleCoVar hole+ ; addTcEvBind ev_binds_var $ mkWantedEvBind co_var err_tm+ ; fillCoercionHole hole (mkTcCoVarCo co_var) }} | otherwise -- Do not set any evidence for Given/Derived = return ()@@ -803,17 +822,21 @@ tryReporters :: ReportErrCtxt -> [ReporterSpec] -> [Ct] -> TcM (ReportErrCtxt, [Ct]) -- Use the first reporter in the list whose predicate says True tryReporters ctxt reporters cts- = do { traceTc "tryReporters {" (ppr cts)- ; (ctxt', cts') <- go ctxt reporters cts+ = do { let (vis_cts, invis_cts) = partition (isVisibleOrigin . ctOrigin) cts+ ; traceTc "tryReporters {" (ppr vis_cts $$ ppr invis_cts)+ ; (ctxt', cts') <- go ctxt reporters vis_cts invis_cts ; traceTc "tryReporters }" (ppr cts') ; return (ctxt', cts') } where- go ctxt [] cts- = return (ctxt, cts)+ go ctxt [] vis_cts invis_cts+ = return (ctxt, vis_cts ++ invis_cts) - go ctxt (r : rs) cts- = do { (ctxt', cts') <- tryReporter ctxt r cts- ; go ctxt' rs cts' }+ go ctxt (r : rs) vis_cts invis_cts+ -- always look at *visible* Origins before invisible ones+ -- this is the whole point of isVisibleOrigin+ = do { (ctxt', vis_cts') <- tryReporter ctxt r vis_cts+ ; (ctxt'', invis_cts') <- tryReporter ctxt' r invis_cts+ ; go ctxt'' rs vis_cts' invis_cts' } -- Carry on with the rest, because we must make -- deferred bindings for them if we have -fdefer-type-errors -- But suppress their error messages@@ -866,10 +889,10 @@ = mkErrorReport ctxt (ctLocEnv (ctLoc ct)) report mkErrorReport :: ReportErrCtxt -> TcLclEnv -> Report -> TcM ErrMsg-mkErrorReport ctxt tcl_env (Report important relevant_bindings)+mkErrorReport ctxt tcl_env (Report important relevant_bindings valid_subs) = do { context <- mkErrInfo (cec_tidy ctxt) (tcl_ctxt tcl_env) ; mkErrDocAt (RealSrcSpan (tcl_loc tcl_env))- (errDoc important [context] relevant_bindings)+ (errDoc important [context] (relevant_bindings ++ valid_subs)) } type UserGiven = Implication@@ -912,9 +935,9 @@ Note [Do not report derived but soluble errors] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The wc_simples include Derived constraints that have not been solved, but are-not insoluble (in that case they'd be in wc_insols). We do not want to report-these as errors:+The wc_simples include Derived constraints that have not been solved,+but are not insoluble (in that case they'd be reported by 'report1').+We do not want to report these as errors: * Superclass constraints. If we have an unsolved [W] Ord a, we'll also have an unsolved [D] Eq a, and we do not want to report that; it's just noise.@@ -978,8 +1001,8 @@ (ct1:_) = cts -----------------mkHoleError :: ReportErrCtxt -> Ct -> TcM ErrMsg-mkHoleError _ctxt ct@(CHoleCan { cc_hole = ExprHole (OutOfScope occ rdr_env0) })+mkHoleError :: [Ct] -> ReportErrCtxt -> Ct -> TcM ErrMsg+mkHoleError _ _ ct@(CHoleCan { cc_hole = ExprHole (OutOfScope occ rdr_env0) }) -- Out-of-scope variables, like 'a', where 'a' isn't bound; suggest possible -- in-scope variables in the message, and note inaccessible exact matches = do { dflags <- getDynFlags@@ -1041,7 +1064,7 @@ th_end_ln = srcSpanEndLine th_loc is_th_bind = th_loc `containsSpan` bind_loc -mkHoleError ctxt ct@(CHoleCan { cc_hole = hole })+mkHoleError tidy_simples ctxt ct@(CHoleCan { cc_hole = hole }) -- Explicit holes, like "_" or "_f" = do { (ctxt, binds_msg, ct) <- relevantBindings False ctxt ct -- The 'False' means "don't filter the bindings"; see Trac #8191@@ -1052,14 +1075,17 @@ = givenConstraintsMsg ctxt | otherwise = empty + ; sub_msg <- validSubstitutions tidy_simples ctxt ct ; mkErrorMsgFromCt ctxt ct $ important hole_msg `mappend`- relevant_bindings (binds_msg $$ constraints_msg) }+ relevant_bindings (binds_msg $$ constraints_msg) `mappend`+ valid_substitutions sub_msg} where- occ = holeOcc hole- hole_ty = ctEvPred (ctEvidence ct)- tyvars = tyCoVarsOfTypeList hole_ty+ occ = holeOcc hole+ hole_ty = ctEvPred (ctEvidence ct)+ hole_kind = typeKind hole_ty+ tyvars = tyCoVarsOfTypeList hole_ty hole_msg = case hole of ExprHole {} -> vcat [ hang (text "Found hole:")@@ -1068,11 +1094,21 @@ TypeHole {} -> vcat [ hang (text "Found type wildcard" <+> quotes (ppr occ)) 2 (text "standing for" <+>- quotes (pprType hole_ty))+ quotes pp_hole_type_with_kind) , tyvars_msg, type_hole_hint ] + pp_hole_type_with_kind+ | isLiftedTypeKind hole_kind = pprType hole_ty+ | otherwise = pprType hole_ty <+> dcolon <+> pprKind hole_kind+ tyvars_msg = ppUnless (null tyvars) $- text "Where:" <+> vcat (map loc_msg tyvars)+ text "Where:" <+> (vcat (map loc_msg other_tvs)+ $$ pprSkols ctxt skol_tvs)+ where+ (skol_tvs, other_tvs) = partition is_skol tyvars+ is_skol tv = isTcTyVar tv && isSkolemTyVar tv+ -- Coercion variables can be free in the+ -- hole, via kind casts type_hole_hint | HoleError <- cec_type_holes ctxt@@ -1091,16 +1127,150 @@ | isTyVar tv = case tcTyVarDetails tv of MetaTv {} -> quotes (ppr tv) <+> text "is an ambiguous type variable"- _ -> extraTyVarInfo ctxt tv- | otherwise+ _ -> empty -- Skolems dealt with already+ | otherwise -- A coercion variable can be free in the hole type = sdocWithDynFlags $ \dflags -> if gopt Opt_PrintExplicitCoercions dflags then quotes (ppr tv) <+> text "is a coercion variable" else empty -mkHoleError _ ct = pprPanic "mkHoleError" (ppr ct)+mkHoleError _ _ ct = pprPanic "mkHoleError" (ppr ct) +-- See Note [Valid substitutions include ...]+validSubstitutions :: [Ct] -> ReportErrCtxt -> Ct -> TcM SDoc+validSubstitutions simples (CEC {cec_encl = implics}) ct | isExprHoleCt ct =+ do { rdr_env <- getGlobalRdrEnv+ ; dflags <- getDynFlags+ ; traceTc "findingValidSubstitutionsFor {" $ ppr wrapped_hole_ty+ ; (discards, substitutions) <-+ setTcLevel hole_lvl $+ go (maxValidSubstitutions dflags) $+ localsFirst $ globalRdrEnvElts rdr_env+ ; traceTc "}" empty+ ; return $ ppUnless (null substitutions) $+ hang (text "Valid substitutions include")+ 2 (vcat (map ppr_sub substitutions)+ $$ ppWhen discards subsDiscardMsg) }+ where+ -- We extract the type of the hole from the constraint.+ hole_ty :: TcPredType+ hole_ty = ctPred ct+ hole_loc = ctEvLoc $ ctEvidence ct+ hole_lvl = ctLocLevel $ hole_loc+ hole_fvs = tyCoFVsOfType hole_ty++ -- For checking, we wrap the type of the hole with all the givens+ -- from all the implications in the context.+ wrapped_hole_ty :: TcSigmaType+ wrapped_hole_ty = foldl' wrapTypeWithImplication hole_ty implics++ -- We rearrange the elements to make locals appear at the top of the list,+ -- since they're most likely to be relevant to the user+ localsFirst :: [GlobalRdrElt] -> [GlobalRdrElt]+ localsFirst elts = lcl ++ gbl+ where (lcl, gbl) = partition gre_lcl elts++ -- For pretty printing, we look up the name and type of the substitution+ -- we found.+ ppr_sub :: (GlobalRdrElt, Id) -> SDoc+ ppr_sub (elt, id) = sep [ idAndTy , nest 2 (parens $ pprNameProvenance elt)]+ where name = gre_name elt+ ty = varType id+ idAndTy = (pprPrefixOcc name <+> dcolon <+> pprType ty)++ -- These are the constraints whose every free unification variable is+ -- mentioned in the type of the hole.+ relevantCts :: [Ct]+ relevantCts = if isEmptyVarSet hole_fv then []+ else filter isRelevant simples+ where hole_fv :: VarSet+ hole_fv = fvVarSet hole_fvs+ ctFreeVarSet :: Ct -> VarSet+ ctFreeVarSet = fvVarSet . tyCoFVsOfType . ctPred+ allFVMentioned :: Ct -> Bool+ allFVMentioned ct = ctFreeVarSet ct `subVarSet` hole_fv+ -- We filter out those constraints that have no variables (since+ -- they won't be solved by finding a type for the type variable+ -- representing the hole) and also other holes, since we're not+ -- trying to find substitutions for many holes at once.+ isRelevant ct = not (isEmptyVarSet (ctFreeVarSet ct))+ && allFVMentioned ct+ && not (isHoleCt ct)+++ -- This creates a substitution with new fresh type variables for all the+ -- free variables mentioned in the type of hole and in the relevant+ -- constraints. Note that since we only pick constraints such that all their+ -- free variables are mentioned by the hole, the free variables of the hole+ -- are all the free variables of the constraints as well.+ getHoleCloningSubst :: TcM TCvSubst+ getHoleCloningSubst = mkTvSubstPrs <$> getClonedVars+ where cloneFV :: TyVar -> TcM (TyVar, Type)+ cloneFV fv = ((,) fv) <$> newFlexiTyVarTy (varType fv)+ getClonedVars :: TcM [(TyVar, Type)]+ getClonedVars = mapM cloneFV (fvVarList hole_fvs)++ -- This applies the given substitution to the given constraint.+ applySubToCt :: TCvSubst -> Ct -> Ct+ applySubToCt sub ct = ct {cc_ev = ev {ctev_pred = subbedPredType} }+ where subbedPredType = substTy sub $ ctPred ct+ ev = ctEvidence ct++ -- The real work happens here, where we invoke the type checker+ -- to check whether we the given type fits into the hole!+ -- To check: Clone all relevant cts and the hole+ -- then solve the subsumption check AND check that all other+ -- the other constraints were solved.+ fitsHole :: Type -> TcM Bool+ fitsHole typ =+ do { traceTc "checkingFitOf {" $ ppr typ+ ; cloneSub <- getHoleCloningSubst+ ; let cHoleTy = substTy cloneSub wrapped_hole_ty+ cCts = map (applySubToCt cloneSub) relevantCts+ ; fits <- tcCheckHoleFit (listToBag cCts) cHoleTy typ+ ; traceTc "}" empty+ ; return fits}++ -- Kickoff the checking of the elements. The first argument+ -- is a counter, so that we stop after finding functions up to+ -- the limit the user gives us.+ go :: Maybe Int -> [GlobalRdrElt] -> TcM (Bool, [(GlobalRdrElt, Id)])+ go = go_ []++ -- We iterate over the elements, checking each one in turn. If+ -- we've already found -fmax-valid-substitutions=n elements, we+ -- look no further.+ go_ :: [(GlobalRdrElt,Id)] -- What we've found so far.+ -> Maybe Int -- How many we're allowed to find, if limited.+ -> [GlobalRdrElt] -- The elements we've yet to check.+ -> TcM (Bool, [(GlobalRdrElt, Id)])+ go_ subs _ [] = return (False, reverse subs)+ go_ subs (Just 0) _ = return (True, reverse subs)+ go_ subs maxleft (el:elts) =+ do { traceTc "lookingUp" $ ppr el+ ; maybeThing <- lookup (gre_name el)+ ; case maybeThing of+ Just id -> do { fits <- fitsHole (varType id)+ ; if fits then (keep_it id) else discard_it }+ _ -> discard_it+ }+ where discard_it = go_ subs maxleft elts+ keep_it id = go_ ((el,id):subs) ((\n -> n - 1) <$> maxleft) elts+ lookup name =+ do { thing <- tcLookup name+ ; case thing of+ ATcId {tct_id = id} -> return $ Just id+ AGlobal (AnId id) -> return $ Just id+ AGlobal (AConLike (RealDataCon con)) ->+ return $ Just (dataConWrapId con)+ _ -> return Nothing }+++-- We don't (as of yet) handle holes in types, only in expressions.+validSubstitutions _ _ _ = return empty++ -- See Note [Constraints include ...] givenConstraintsMsg :: ReportErrCtxt -> SDoc givenConstraintsMsg ctxt =@@ -1130,7 +1300,7 @@ msg | null givens = addArising orig $ sep [ text "Unbound implicit parameter" <> plural cts- , nest 2 (pprTheta preds) ]+ , nest 2 (pprParendTheta preds) ] | otherwise = couldNotDeduce givens (preds, orig) @@ -1140,6 +1310,75 @@ (ct1:_) = cts {-+Note [Valid substitutions include ...]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+`validSubstitutions` returns the "Valid substitutions include ..." message.+For example, look at the following definitions in a file called test.hs:++ import Data.List (inits)++ f :: [String]+ f = _ "hello, world"++The hole in `f` would generate the message:++ • Found hole: _ :: [Char] -> [String]+ • In the expression: _+ In the expression: _ "hello, world"+ In an equation for ‘f’: f = _ "hello, world"+ • Relevant bindings include f :: [String] (bound at test.hs:6:1)+ Valid substitutions include+ inits :: forall a. [a] -> [[a]]+ (imported from ‘Data.List’ at test.hs:3:19-23+ (and originally defined in ‘base-4.11.0.0:Data.OldList’))+ return :: forall (m :: * -> *). Monad m => forall a. a -> m a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.Base’))+ fail :: forall (m :: * -> *). Monad m => forall a. String -> m a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.Base’))+ mempty :: forall a. Monoid a => a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.Base’))+ pure :: forall (f :: * -> *). Applicative f => forall a. a -> f a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.Base’))+ read :: forall a. Read a => String -> a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘Text.Read’))+ lines :: String -> [String]+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘base-4.11.0.0:Data.OldList’))+ words :: String -> [String]+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘base-4.11.0.0:Data.OldList’))+ error :: forall (a :: TYPE r). GHC.Stack.Types.HasCallStack => [Char] -> a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.Err’))+ errorWithoutStackTrace :: forall (a :: TYPE r). [Char] -> a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.Err’))+ undefined :: forall (a :: TYPE r). GHC.Stack.Types.HasCallStack => a+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.Err’))+ repeat :: forall a. a -> [a]+ (imported from ‘Prelude’ at test.hs:1:8-11+ (and originally defined in ‘GHC.List’))++Valid substitutions are found by checking top level identifiers in scope for+whether their type is subsumed by the type of the hole. Additionally, as+highlighted by Trac #14273, we also need to check whether all relevant+constraints are solved by choosing an identifier of that type as well. This is+to make sure we don't suggest a substitution which does not fulfill the+constraints imposed on the hole (even though it has a type that would otherwise+fit the hole). The relevant constraints are those whose free unification+variables are all mentioned by the type of the hole. Since checking for+subsumption results in the side effect of type variables being unified by the+simplifier, we need to take care to clone the variables in the hole and relevant+constraints before checking whether an identifier fits into the hole, to avoid+affecting the hole and later checks.++ Note [Constraints include ...] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 'givenConstraintsMsg' returns the "Constraints include ..." message enabled by@@ -1302,9 +1541,9 @@ any more. So we don't assert that it is. -} -mkEqErr :: ReportErrCtxt -> [Ct] -> TcM ErrMsg -- Don't have multiple equality errors from the same location -- E.g. (Int,Bool) ~ (Bool,Int) one error will do!+mkEqErr :: ReportErrCtxt -> [Ct] -> TcM ErrMsg mkEqErr ctxt (ct:_) = mkEqErr1 ctxt ct mkEqErr _ [] = panic "mkEqErr" @@ -1321,7 +1560,7 @@ NomEq -> empty ReprEq -> mkCoercibleExplanation rdr_env fam_envs ty1 ty2 ; dflags <- getDynFlags- ; traceTc "mkEqErr1" (ppr ct $$ pprCtOrigin (ctOrigin ct))+ ; traceTc "mkEqErr1" (ppr ct $$ pprCtOrigin (ctOrigin ct) $$ ppr keep_going) ; let report = mconcat [important wanted_msg, important coercible_msg, relevant_bindings binds_msg] ; if keep_going@@ -1403,7 +1642,7 @@ has_unknown_roles ty | Just (tc, tys) <- tcSplitTyConApp_maybe ty- = length tys >= tyConArity tc -- oversaturated tycon+ = tys `lengthAtLeast` tyConArity tc -- oversaturated tycon | Just (s, _) <- tcSplitAppTy_maybe ty = has_unknown_roles s | isTyVarTy ty@@ -1444,9 +1683,12 @@ -> Maybe SwapFlag -- Nothing <=> not sure -> TcType -> TcType -> TcM ErrMsg mkEqErr_help dflags ctxt report ct oriented ty1 ty2- | Just tv1 <- tcGetTyVar_maybe ty1 = mkTyVarEqErr dflags ctxt report ct oriented tv1 ty2- | Just tv2 <- tcGetTyVar_maybe ty2 = mkTyVarEqErr dflags ctxt report ct swapped tv2 ty1- | otherwise = reportEqErr ctxt report ct oriented ty1 ty2+ | Just (tv1, co1) <- tcGetCastedTyVar_maybe ty1+ = mkTyVarEqErr dflags ctxt report ct oriented tv1 co1 ty2+ | Just (tv2, co2) <- tcGetCastedTyVar_maybe ty2+ = mkTyVarEqErr dflags ctxt report ct swapped tv2 co2 ty1+ | otherwise+ = reportEqErr ctxt report ct oriented ty1 ty2 where swapped = fmap flipSwap oriented @@ -1459,15 +1701,21 @@ where misMatch = important $ misMatchOrCND ctxt ct oriented ty1 ty2 eqInfo = important $ mkEqInfoMsg ct ty1 ty2 -mkTyVarEqErr :: DynFlags -> ReportErrCtxt -> Report -> Ct- -> Maybe SwapFlag -> TcTyVar -> TcType -> TcM ErrMsg+mkTyVarEqErr, mkTyVarEqErr'+ :: DynFlags -> ReportErrCtxt -> Report -> Ct+ -> Maybe SwapFlag -> TcTyVar -> TcCoercionN -> TcType -> TcM ErrMsg -- tv1 and ty2 are already tidied-mkTyVarEqErr dflags ctxt report ct oriented tv1 ty2- | isUserSkolem ctxt tv1 -- ty2 won't be a meta-tyvar, or else the thing would+mkTyVarEqErr dflags ctxt report ct oriented tv1 co1 ty2+ = do { traceTc "mkTyVarEqErr" (ppr ct $$ ppr tv1 $$ ppr co1 $$ ppr ty2)+ ; mkTyVarEqErr' dflags ctxt report ct oriented tv1 co1 ty2 }++mkTyVarEqErr' dflags ctxt report ct oriented tv1 co1 ty2+ | not insoluble_occurs_check -- See Note [Occurs check wins]+ , isUserSkolem ctxt tv1 -- ty2 won't be a meta-tyvar, or else the thing would -- be oriented the other way round; -- see TcCanonical.canEqTyVarTyVar- || isSigTyVar tv1 && not (isTyVarTy ty2)- || ctEqRel ct == ReprEq && not insoluble_occurs_check+ || isSigTyVar tv1 && not (isTyVarTy ty2)+ || ctEqRel ct == ReprEq -- the cases below don't really apply to ReprEq (except occurs check) = mkErrorMsgFromCt ctxt ct $ mconcat [ important $ misMatchOrCND ctxt ct oriented ty1 ty2@@ -1477,7 +1725,7 @@ | OC_Occurs <- occ_check_expand -- We report an "occurs check" even for a ~ F t a, where F is a type- -- function; it's not insouble (because in principle F could reduce)+ -- function; it's not insoluble (because in principle F could reduce) -- but we have certainly been unable to solve it -- See Note [Occurs check error] in TcCanonical = do { let main_msg = addArising (ctOrigin ct) $@@ -1510,6 +1758,23 @@ -- to be helpful since this is just an unimplemented feature. ; mkErrorMsgFromCt ctxt ct $ report { report_important = [msg] } } + -- check for heterogeneous equality next; see Note [Equalities with incompatible kinds]+ -- in TcCanonical+ | not (k1 `tcEqType` k2)+ = do { let main_msg = addArising (ctOrigin ct) $+ vcat [ hang (text "Kind mismatch: cannot unify" <+>+ parens (ppr tv1 <+> dcolon <+> ppr (tyVarKind tv1)) <+>+ text "with:")+ 2 (sep [ppr ty2, dcolon, ppr k2])+ , text "Their kinds differ." ]+ cast_msg+ | isTcReflexiveCo co1 = empty+ | otherwise = text "NB:" <+> ppr tv1 <+>+ text "was casted to have kind" <+>+ quotes (ppr k1)++ ; mkErrorMsgFromCt ctxt ct (mconcat [important main_msg, important cast_msg, report]) }+ -- If the immediately-enclosing implication has 'tv' a skolem, and -- we know by now its an InferSkol kind of skolem, then presumably -- it started life as a SigTv, else it'd have been unified, given@@ -1555,7 +1820,7 @@ , Implic { ic_env = env, ic_given = given , ic_tclvl = lvl, ic_info = skol_info } <- implic = ASSERT2( not (isTouchableMetaTyVar lvl tv1)- , ppr tv1 ) -- See Note [Error messages for untouchables]+ , ppr tv1 $$ ppr lvl ) -- See Note [Error messages for untouchables] do { let msg = important $ misMatchMsg ct oriented ty1 ty2 tclvl_extra = important $ nest 2 $@@ -1574,6 +1839,9 @@ -- Consider an ambiguous top-level constraint (a ~ F a) -- Not an occurs check, because F is a type function. where+ Pair _ k1 = tcCoercionKind co1+ k2 = typeKind ty2+ ty1 = mkTyVarTy tv1 occ_check_expand = occCheckForErrors dflags tv1 ty2 insoluble_occurs_check = isInsolubleOccursCheck (ctEqRel ct) tv1 ty2@@ -1615,8 +1883,9 @@ tyfun_msg | Just tc1 <- mb_fun1 , Just tc2 <- mb_fun2 , tc1 == tc2+ , not (isInjectiveTyCon tc1 Nominal) = text "NB:" <+> quotes (ppr tc1)- <+> text "is a type function, and may not be injective"+ <+> text "is a non-injective type family" | otherwise = empty isUserSkolem :: ReportErrCtxt -> TcTyVar -> Bool@@ -1681,13 +1950,9 @@ extraTyVarInfo ctxt tv = ASSERT2( isTyVar tv, ppr tv ) case tcTyVarDetails tv of- SkolemTv {} -> pprSkol implics tv- FlatSkol {} -> pp_tv <+> text "is a flattening type variable"- RuntimeUnk {} -> pp_tv <+> text "is an interactive-debugger skolem"+ SkolemTv {} -> pprSkols ctxt [tv]+ RuntimeUnk {} -> quotes (ppr tv) <+> text "is an interactive-debugger skolem" MetaTv {} -> empty- where- implics = cec_encl ctxt- pp_tv = quotes (ppr tv) suggestAddSig :: ReportErrCtxt -> TcType -> TcType -> SDoc -- See Note [Suggest adding a type signature]@@ -1702,7 +1967,8 @@ inferred_bndrs = nub (get_inf ty1 ++ get_inf ty2) get_inf ty | Just tv <- tcGetTyVar_maybe ty , isSkolemTyVar tv- , InferSkol prs <- ic_info (getSkolemInfo (cec_encl ctxt) tv)+ , (implic, _) : _ <- getSkolemInfo (cec_encl ctxt) [tv]+ , InferSkol prs <- ic_info implic = map fst prs | otherwise = []@@ -1812,7 +2078,7 @@ -> empty thing_msg = case maybe_thing of- Just thing -> \_ -> quotes (ppr thing) <+> text "is"+ Just thing -> \_ -> quotes thing <+> text "is" Nothing -> \vowel -> text "got a" <> if vowel then char 'n' else empty msg2 = sep [ text "Expecting a lifted type, but"@@ -1822,38 +2088,39 @@ msg4 = maybe_num_args_msg $$ sep [ text "Expected a type, but" , maybe (text "found something with kind")- (\thing -> quotes (ppr thing) <+> text "has kind")+ (\thing -> quotes thing <+> text "has kind") maybe_thing , quotes (ppr act) ] msg5 th = hang (text "Expected" <+> kind_desc <> comma)- 2 (text "but" <+> quotes (ppr th) <+> text "has kind" <+>+ 2 (text "but" <+> quotes th <+> text "has kind" <+> quotes (ppr act)) where kind_desc | isConstraintKind exp = text "a constraint" | otherwise = text "kind" <+> quotes (ppr exp) num_args_msg = case level of- TypeLevel -> Nothing KindLevel+ | not (isMetaTyVarTy exp) && not (isMetaTyVarTy act)+ -- if one is a meta-tyvar, then it's possible that the user+ -- has asked for something impredicative, and we couldn't unify.+ -- Don't bother with counting arguments. -> let n_act = count_args act n_exp = count_args exp in case n_act - n_exp of- n | n /= 0+ n | n > 0 -- we don't know how many args there are, so don't+ -- recommend removing args that aren't , Just thing <- maybe_thing- , case errorThingNumArgs_maybe thing of- Nothing -> n > 0- Just num_act_args -> num_act_args >= -n- -- don't report to strip off args that aren't there -> Just $ text "Expecting" <+> speakN (abs n) <+>- more_or_fewer <+> quotes (ppr thing)+ more <+> quotes thing where- more_or_fewer- | n < 0 = text "fewer arguments to"+ more | n == 1 = text "more argument to" | otherwise = text "more arguments to" -- n > 1 _ -> Nothing + _ -> Nothing+ maybe_num_args_msg = case num_args_msg of Nothing -> empty Just m -> m@@ -1871,7 +2138,22 @@ mkExpectedActualMsg _ _ _ _ _ = panic "mkExpectedAcutalMsg" -{-+{- Note [Insoluble occurs check wins]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider [G] a ~ [a], [W] a ~ [a] (Trac #13674). The Given is insoluble+so we don't use it for rewriting. The Wanted is also insoluble, and+we don't solve it from the Given. It's very confusing to say+ Cannot solve a ~ [a] from given constraints a ~ [a]++And indeed even thinking about the Givens is silly; [W] a ~ [a] is+just as insoluble as Int ~ Bool.++Conclusion: if there's an insoluble occurs check (isInsolubleOccursCheck)+then report it first.++(NB: there are potentially-soluble ones, like (a ~ F a b), and we don't+want to be as draconian with them.)+ Note [Expanding type synonyms to make types similar] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -2145,10 +2427,7 @@ -- When simplifying [W] Ord (Set a), we need -- [W] Eq a, [W] Ord a -- but we really only want to report the latter- elim_superclasses cts- = filter (\ct -> any (eqType (ctPred ct)) min_preds) cts- where- min_preds = mkMinimalBySCs (map ctPred cts)+ elim_superclasses cts = mkMinimalBySCs ctPred cts mk_dict_err :: ReportErrCtxt -> (Ct, ClsInstLookupResult) -> TcM (ReportErrCtxt, SDoc)@@ -2338,7 +2617,7 @@ -- Overlap error because of Safe Haskell (first -- match should be the most specific match) safe_haskell_msg- = ASSERT( length matches == 1 && not (null unsafe_ispecs) )+ = ASSERT( matches `lengthIs` 1 && not (null unsafe_ispecs) ) vcat [ addArising orig (text "Unsafe overlapping instances for" <+> pprType (mkClassPred clas tys)) , sep [text "The matching instance is:",@@ -2541,7 +2820,7 @@ <+> text "involving out-of-scope types") 2 (ppWhen show_potentials (pprInstances not_in_scope)) - flag_hint = ppUnless (show_potentials || length show_these == length insts) $+ flag_hint = ppUnless (show_potentials || equalLength show_these insts) $ text "(use -fprint-potential-instances to see them all)" {- Note [Displaying potential instances]@@ -2626,18 +2905,25 @@ is_or_are [_] = text "is" is_or_are _ = text "are" -pprSkol :: [Implication] -> TcTyVar -> SDoc-pprSkol implics tv- = case skol_info of- UnkSkol -> quotes (ppr tv) <+> text "is an unknown type variable"- _ -> ppr_rigid (pprSkolInfo skol_info)+pprSkols :: ReportErrCtxt -> [TcTyVar] -> SDoc+pprSkols ctxt tvs+ = vcat (map pp_one (getSkolemInfo (cec_encl ctxt) tvs)) where- Implic { ic_info = skol_info } = getSkolemInfo implics tv- ppr_rigid pp_info- = hang (quotes (ppr tv) <+> text "is a rigid type variable bound by")- 2 (sep [ pp_info- , text "at" <+> ppr (getSrcSpan tv) ])+ pp_one (Implic { ic_info = skol_info }, tvs)+ | UnkSkol <- skol_info+ = hang (pprQuotedList tvs)+ 2 (is_or_are tvs "an" "unknown")+ | otherwise+ = vcat [ hang (pprQuotedList tvs)+ 2 (is_or_are tvs "a" "rigid" <+> text "bound by")+ , nest 2 (pprSkolInfo skol_info)+ , nest 2 (text "at" <+> ppr (foldr1 combineSrcSpans (map getSrcSpan tvs))) ] + is_or_are [_] article adjective = text "is" <+> text article <+> text adjective+ <+> text "type variable"+ is_or_are _ _ adjective = text "are" <+> text adjective+ <+> text "type variables"+ getAmbigTkvs :: Ct -> ([Var],[Var]) getAmbigTkvs ct = partition (`elemVarSet` dep_tkv_set) ambig_tkvs@@ -2646,16 +2932,24 @@ ambig_tkvs = filter isAmbiguousTyVar tkvs dep_tkv_set = tyCoVarsOfTypes (map tyVarKind tkvs) -getSkolemInfo :: [Implication] -> TcTyVar -> Implication--- Get the skolem info for a type variable--- from the implication constraint that binds it-getSkolemInfo [] tv- = pprPanic "No skolem info:" (ppr tv)+getSkolemInfo :: [Implication] -> [TcTyVar]+ -> [(Implication, [TcTyVar])]+-- Get the skolem info for some type variables+-- from the implication constraints that bind them+--+-- In the returned (implic, tvs) pairs, the 'tvs' part is non-empty+getSkolemInfo _ []+ = [] -getSkolemInfo (implic:implics) tv- | tv `elem` ic_skols implic = implic- | otherwise = getSkolemInfo implics tv+getSkolemInfo [] tvs+ = pprPanic "No skolem info:" (ppr tvs) +getSkolemInfo (implic:implics) tvs+ | null tvs_here = getSkolemInfo implics tvs+ | otherwise = (implic, tvs_here) : getSkolemInfo implics tvs_other+ where+ (tvs_here, tvs_other) = partition (`elem` ic_skols implic) tvs+ ----------------------- -- relevantBindings looks at the value environment and finds values whose -- types mention any of the offending type variables. It has to be@@ -2721,7 +3015,7 @@ ---- fixes #12177 ---- builds up a list of bindings whose OccName has not been seen before- remove_shadowing :: [TcIdBinder] -> [TcIdBinder]+ remove_shadowing :: [TcBinder] -> [TcBinder] remove_shadowing bindings = reverse $ fst $ foldl (\(bindingAcc, seenNames) binding -> if (occName binding) `elemOccSet` seenNames -- if we've seen it@@ -2731,13 +3025,14 @@ go :: DynFlags -> TidyEnv -> TcTyVarSet -> Maybe Int -> TcTyVarSet -> [SDoc] -> Bool -- True <=> some filtered out due to lack of fuel- -> [TcIdBinder]+ -> [TcBinder] -> TcM (TidyEnv, [SDoc], Bool) -- The bool says if we filtered any out -- because of lack of fuel go _ tidy_env _ _ _ docs discards [] = return (tidy_env, reverse docs, discards) go dflags tidy_env ct_tvs n_left tvs_seen docs discards (tc_bndr : tc_bndrs) = case tc_bndr of+ TcTvBndr {} -> discard_it TcIdBndr id top_lvl -> go2 (idName id) (idType id) top_lvl TcIdBndr_ExpType name et top_lvl -> do { mb_ty <- readExpType_maybe et@@ -2787,6 +3082,11 @@ discardMsg :: SDoc discardMsg = text "(Some bindings suppressed;" <+> text "use -fmax-relevant-binds=N or -fno-max-relevant-binds)"++subsDiscardMsg :: SDoc+subsDiscardMsg =+ text "(Some substitutions suppressed;" <+>+ text "use -fmax-valid-substitutions=N or -fno-max-valid-substitutions)" ----------------------- warnDefaulting :: [Ct] -> Type -> TcM ()
typecheck/TcEvidence.hs view
@@ -13,7 +13,8 @@ -- Evidence bindings TcEvBinds(..), EvBindsVar(..), EvBindMap(..), emptyEvBindMap, extendEvBinds,- lookupEvBind, evBindMapBinds, foldEvBindMap, isEmptyEvBindMap,+ lookupEvBind, evBindMapBinds, foldEvBindMap, filterEvBindMap,+ isEmptyEvBindMap, EvBind(..), emptyTcEvBinds, isEmptyTcEvBinds, mkGivenEvBind, mkWantedEvBind, sccEvBinds, evBindVar, EvTerm(..), mkEvCast, evVarsOfTerm, mkEvScSelectors,@@ -33,12 +34,14 @@ mkTcKindCo, tcCoercionKind, coVarsOfTcCo, mkTcCoVarCo,- isTcReflCo,+ isTcReflCo, isTcReflexiveCo, tcCoercionRole, unwrapIP, wrapIP ) where #include "HsVersions.h" +import GhcPrelude+ import Var import CoAxiom import Coercion@@ -115,6 +118,10 @@ coVarsOfTcCo :: TcCoercion -> TcTyCoVarSet isTcReflCo :: TcCoercion -> Bool +-- | This version does a slow check, calculating the related types and seeing+-- if they are equal.+isTcReflexiveCo :: TcCoercion -> Bool+ mkTcReflCo = mkReflCo mkTcSymCo = mkSymCo mkTcTransCo = mkTransCo@@ -143,7 +150,7 @@ tcCoercionRole = coercionRole coVarsOfTcCo = coVarsOfCo isTcReflCo = isReflCo-+isTcReflexiveCo = isReflexiveCo {- %************************************************************************@@ -436,6 +443,10 @@ foldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a foldEvBindMap k z bs = foldDVarEnv k z (ev_bind_varenv bs) +filterEvBindMap :: (EvBind -> Bool) -> EvBindMap -> EvBindMap+filterEvBindMap k (EvBindMap { ev_bind_varenv = env })+ = EvBindMap { ev_bind_varenv = filterDVarEnv k env }+ instance Outputable EvBindMap where ppr (EvBindMap m) = ppr m @@ -805,12 +816,12 @@ sccEvBinds :: Bag EvBind -> [SCC EvBind] sccEvBinds bs = stronglyConnCompFromEdgedVerticesUniq edges where- edges :: [(EvBind, EvVar, [EvVar])]+ edges :: [ Node EvVar EvBind ] edges = foldrBag ((:) . mk_node) [] bs - mk_node :: EvBind -> (EvBind, EvVar, [EvVar])+ mk_node :: EvBind -> Node EvVar EvBind mk_node b@(EvBind { eb_lhs = var, eb_rhs = term })- = (b, var, nonDetEltsUniqSet (evVarsOfTerm term `unionVarSet`+ = DigraphNode b var (nonDetEltsUniqSet (evVarsOfTerm term `unionVarSet` coVarsOfType (varType var))) -- It's OK to use nonDetEltsUniqSet here as stronglyConnCompFromEdgedVertices -- is still deterministic even if the edges are in nondeterministic order
typecheck/TcExpr.hs view
@@ -8,6 +8,7 @@ {-# LANGUAGE CPP, TupleSections, ScopedTypeVariables #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-} module TcExpr ( tcPolyExpr, tcMonoExpr, tcMonoExprNC, tcInferSigma, tcInferSigmaNC, tcInferRho, tcInferRhoNC,@@ -18,6 +19,8 @@ #include "HsVersions.h" +import GhcPrelude+ import {-# SOURCE #-} TcSplice( tcSpliceExpr, tcTypedBracket, tcUntypedBracket ) import THNames( liftStringName, liftName ) @@ -32,8 +35,8 @@ import TcSimplify ( simplifyInfer, InferMode(..) ) import FamInst ( tcGetFamInstEnvs, tcLookupDataFamInst ) import FamInstEnv ( FamInstEnvs )-import RnEnv ( addUsedGRE, addNameClashErrRn- , unknownSubordinateErr )+import RnEnv ( addUsedGRE )+import RnUtils ( addNameClashErrRn, unknownSubordinateErr ) import TcEnv import TcArrows import TcMatches@@ -53,6 +56,7 @@ import NameSet import RdrName import TyCon+import TyCoRep import Type import TcEvidence import VarSet@@ -75,7 +79,6 @@ import Data.Function import Data.List-import Data.Either import qualified Data.Set as Set {-@@ -87,9 +90,9 @@ -} tcPolyExpr, tcPolyExprNC- :: LHsExpr Name -- Expression to type check- -> TcSigmaType -- Expected type (could be a polytype)- -> TcM (LHsExpr TcId) -- Generalised expr with expected type+ :: LHsExpr GhcRn -- Expression to type check+ -> TcSigmaType -- Expected type (could be a polytype)+ -> TcM (LHsExpr GhcTcId) -- Generalised expr with expected type -- tcPolyExpr is a convenient place (frequent but not too frequent) -- place to add context information.@@ -100,7 +103,8 @@ tcPolyExprNC expr res_ty = tc_poly_expr_nc expr (mkCheckExpType res_ty) -- these versions take an ExpType-tc_poly_expr, tc_poly_expr_nc :: LHsExpr Name -> ExpSigmaType -> TcM (LHsExpr TcId)+tc_poly_expr, tc_poly_expr_nc :: LHsExpr GhcRn -> ExpSigmaType+ -> TcM (LHsExpr GhcTcId) tc_poly_expr expr res_ty = addExprErrCtxt expr $ do { traceTc "tcPolyExpr" (ppr res_ty); tc_poly_expr_nc expr res_ty }@@ -117,10 +121,10 @@ --------------- tcMonoExpr, tcMonoExprNC- :: LHsExpr Name -- Expression to type check+ :: LHsExpr GhcRn -- Expression to type check -> ExpRhoType -- Expected type -- Definitely no foralls at the top- -> TcM (LHsExpr TcId)+ -> TcM (LHsExpr GhcTcId) tcMonoExpr expr res_ty = addErrCtxt (exprCtxt expr) $@@ -132,7 +136,7 @@ ; return (L loc expr') } ----------------tcInferSigma, tcInferSigmaNC :: LHsExpr Name -> TcM ( LHsExpr TcId+tcInferSigma, tcInferSigmaNC :: LHsExpr GhcRn -> TcM ( LHsExpr GhcTcId , TcSigmaType ) -- Infer a *sigma*-type. tcInferSigma expr = addErrCtxt (exprCtxt expr) (tcInferSigmaNC expr)@@ -142,7 +146,7 @@ do { (expr', sigma) <- tcInferNoInst (tcExpr expr) ; return (L loc expr', sigma) } -tcInferRho, tcInferRhoNC :: LHsExpr Name -> TcM (LHsExpr TcId, TcRhoType)+tcInferRho, tcInferRhoNC :: LHsExpr GhcRn -> TcM (LHsExpr GhcTcId, TcRhoType) -- Infer a *rho*-type. The return type is always (shallowly) instantiated. tcInferRho expr = addErrCtxt (exprCtxt expr) (tcInferRhoNC expr) @@ -162,15 +166,16 @@ NB: The res_ty is always deeply skolemised. -} -tcExpr :: HsExpr Name -> ExpRhoType -> TcM (HsExpr TcId)-tcExpr (HsVar (L _ name)) res_ty = tcCheckId name res_ty-tcExpr (HsUnboundVar uv) res_ty = tcUnboundId uv res_ty+tcExpr :: HsExpr GhcRn -> ExpRhoType -> TcM (HsExpr GhcTcId)+tcExpr (HsVar (L _ name)) res_ty = tcCheckId name res_ty+tcExpr e@(HsUnboundVar uv) res_ty = tcUnboundId e uv res_ty tcExpr e@(HsApp {}) res_ty = tcApp1 e res_ty tcExpr e@(HsAppType {}) res_ty = tcApp1 e res_ty -tcExpr e@(HsLit lit) res_ty = do { let lit_ty = hsLitType lit- ; tcWrapResult e (HsLit lit) lit_ty res_ty }+tcExpr e@(HsLit lit) res_ty+ = do { let lit_ty = hsLitType lit+ ; tcWrapResult e (HsLit (convertLit lit)) lit_ty res_ty } tcExpr (HsPar expr) res_ty = do { expr' <- tcMonoExprNC expr res_ty ; return (HsPar expr') }@@ -211,7 +216,7 @@ ip_ty res_ty } where -- Coerces a dictionary for `IP "x" t` into `t`.- fromDict ipClass x ty = HsWrap $ mkWpCastR $+ fromDict ipClass x ty = mkHsWrap $ mkWpCastR $ unwrapIP $ mkClassPred ipClass [x,ty] origin = IPOccOrigin x @@ -230,7 +235,7 @@ where -- Coerces a dictionary for `IsLabel "x" t` into `t`, -- or `HasField "x" r a into `r -> a`.- fromDict pred = HsWrap $ mkWpCastR $ unwrapIP pred+ fromDict pred = mkHsWrap $ mkWpCastR $ unwrapIP pred origin = OverLabelOrigin l lbl = mkStrLitTy l @@ -354,8 +359,8 @@ tc_poly_expr_nc arg2 arg2_exp_ty ; arg2_ty <- readExpType arg2_exp_ty ; op_id <- tcLookupId op_name- ; let op' = L loc (HsWrap (mkWpTyApps [arg1_ty, arg2_ty])- (HsVar (L lv op_id)))+ ; let op' = L loc (mkHsWrap (mkWpTyApps [arg1_ty, arg2_ty])+ (HsVar (L lv op_id))) ; return $ OpApp arg1' op' fix arg2' } | (L loc (HsVar (L lv op_name))) <- op@@ -366,7 +371,7 @@ ; let doc = text "The first argument of ($) takes" orig1 = lexprCtOrigin arg1 ; (wrap_arg1, [arg2_sigma], op_res_ty) <-- matchActualFunTys doc orig1 (Just arg1) 1 arg1_ty+ matchActualFunTys doc orig1 (Just (unLoc arg1)) 1 arg1_ty -- We have (arg1 $ arg2) -- So: arg1_ty = arg2_ty -> op_res_ty@@ -381,7 +386,7 @@ -- -- The *result* type can have any kind (Trac #8739), -- so we don't need to check anything for that- ; _ <- unifyKind (Just arg2_sigma) (typeKind arg2_sigma) liftedTypeKind+ ; _ <- unifyKind (Just (HsCoreTy arg2_sigma)) (typeKind arg2_sigma) liftedTypeKind -- ignore the evidence. arg2_sigma must have type * or #, -- because we know arg2_sigma -> or_res_ty is well-kinded -- (because otherwise matchActualFunTys would fail)@@ -392,10 +397,10 @@ ; op_id <- tcLookupId op_name ; res_ty <- readExpType res_ty- ; let op' = L loc (HsWrap (mkWpTyApps [ getRuntimeRep res_ty- , arg2_sigma- , res_ty])- (HsVar (L lv op_id)))+ ; let op' = L loc (mkHsWrap (mkWpTyApps [ getRuntimeRep res_ty+ , arg2_sigma+ , res_ty])+ (HsVar (L lv op_id))) -- arg1' :: arg1_ty -- wrap_arg1 :: arg1_ty "->" (arg2_sigma -> op_res_ty) -- wrap_res :: op_res_ty "->" res_ty@@ -419,9 +424,9 @@ | otherwise = do { traceTc "Non Application rule" (ppr op)- ; (wrap, op', [Left arg1', Left arg2'])+ ; (wrap, op', [HsValArg arg1', HsValArg arg2']) <- tcApp (Just $ mk_op_msg op)- op [Left arg1, Left arg2] res_ty+ op [HsValArg arg1, HsValArg arg2] res_ty ; return (mkHsWrap wrap $ OpApp arg1' op' fix arg2') } -- Right sections, equivalent to \ x -> x `op` expr, or@@ -430,7 +435,7 @@ tcExpr expr@(SectionR op arg2) res_ty = do { (op', op_ty) <- tcInferFun op ; (wrap_fun, [arg1_ty, arg2_ty], op_res_ty)- <- matchActualFunTys (mk_op_msg op) fn_orig (Just op) 2 op_ty+ <- matchActualFunTys (mk_op_msg op) fn_orig (Just (unLoc op)) 2 op_ty ; wrap_res <- tcSubTypeHR SectionOrigin (Just expr) (mkFunTy arg1_ty op_res_ty) res_ty ; arg2' <- tcArg op arg2 arg2_ty 2@@ -449,7 +454,7 @@ | otherwise = 2 ; (wrap_fn, (arg1_ty:arg_tys), op_res_ty)- <- matchActualFunTys (mk_op_msg op) fn_orig (Just op)+ <- matchActualFunTys (mk_op_msg op) fn_orig (Just (unLoc op)) n_reqd_args op_ty ; wrap_res <- tcSubTypeHR SectionOrigin (Just expr) (mkFunTys arg_tys op_res_ty) res_ty@@ -607,6 +612,12 @@ -- Typechecks the static form and wraps it with a call to 'fromStaticPtr'. -- See Note [Grand plan for static forms] in StaticPtrTable for an overview.+-- To type check+-- (static e) :: p a+-- we want to check (e :: a),+-- and wrap (static e) in a call to+-- fromStaticPtr :: IsStatic p => StaticPtr a -> p a+ tcExpr (HsStatic fvs expr) res_ty = do { res_ty <- expTypeToType res_ty ; (co, (p_ty, expr_ty)) <- matchExpectedAppTy res_ty@@ -615,6 +626,7 @@ 2 (ppr expr) ) $ tcPolyExprNC expr expr_ty+ -- Check that the free variables of the static form are closed. -- It's OK to use nonDetEltsUniqSet here as the only side effects of -- checkClosedInStaticForm are error messages.@@ -628,6 +640,7 @@ ; _ <- emitWantedEvVar StaticOrigin $ mkTyConApp (classTyCon typeableClass) [liftedTypeKind, expr_ty]+ -- Insert the constraints of the static form in a global list for later -- validation. ; emitStaticConstraints lie@@ -926,7 +939,7 @@ ; wrap_res <- tcSubTypeHR (exprCtOrigin expr) (Just expr) rec_res_ty res_ty- ; co_scrut <- unifyType (Just record_expr) record_rho scrut_ty+ ; co_scrut <- unifyType (Just (unLoc record_expr)) record_rho scrut_ty -- NB: normal unification is OK here (as opposed to subsumption), -- because for this to work out, both record_rho and scrut_ty have -- to be normal datatypes -- no contravariant stuff can go on@@ -962,8 +975,8 @@ , rupd_cons = relevant_cons, rupd_in_tys = scrut_inst_tys , rupd_out_tys = result_inst_tys, rupd_wrap = req_wrap } } -tcExpr (HsRecFld f) res_ty- = tcCheckRecSelId f res_ty+tcExpr e@(HsRecFld f) res_ty+ = tcCheckRecSelId e f res_ty {- ************************************************************************@@ -1025,10 +1038,10 @@ tcExpr expr res_ty tcExpr (HsSpliceE splice) res_ty = tcSpliceExpr splice res_ty-tcExpr (HsBracket brack) res_ty- = tcTypedBracket brack res_ty-tcExpr (HsRnBracketOut brack ps) res_ty- = tcUntypedBracket brack ps res_ty+tcExpr e@(HsBracket brack) res_ty+ = tcTypedBracket e brack res_ty+tcExpr e@(HsRnBracketOut brack ps) res_ty+ = tcUntypedBracket e brack ps res_ty {- ************************************************************************@@ -1050,8 +1063,8 @@ ************************************************************************ -} -tcArithSeq :: Maybe (SyntaxExpr Name) -> ArithSeqInfo Name -> ExpRhoType- -> TcM (HsExpr TcId)+tcArithSeq :: Maybe (SyntaxExpr GhcRn) -> ArithSeqInfo GhcRn -> ExpRhoType+ -> TcM (HsExpr GhcTcId) tcArithSeq witness seq@(From expr) res_ty = do { (wrap, elt_ty, wit') <- arithSeqEltType witness res_ty@@ -1090,8 +1103,8 @@ ArithSeq eft wit' (FromThenTo expr1' expr2' expr3') } ------------------arithSeqEltType :: Maybe (SyntaxExpr Name) -> ExpRhoType- -> TcM (HsWrapper, TcType, Maybe (SyntaxExpr Id))+arithSeqEltType :: Maybe (SyntaxExpr GhcRn) -> ExpRhoType+ -> TcM (HsWrapper, TcType, Maybe (SyntaxExpr GhcTc)) arithSeqEltType Nothing res_ty = do { res_ty <- expTypeToType res_ty ; (coi, elt_ty) <- matchExpectedListTy res_ty@@ -1110,24 +1123,30 @@ ************************************************************************ -} -type LHsExprArgIn = Either (LHsExpr Name) (LHsWcType Name)-type LHsExprArgOut = Either (LHsExpr TcId) (LHsWcType Name)- -- Left e => argument expression- -- Right ty => visible type application+data HsArg tm ty+ = HsValArg tm -- Argument is an ordinary expression (f arg)+ | HsTypeArg ty -- Argument is a visible type application (f @ty) -tcApp1 :: HsExpr Name -- either HsApp or HsAppType- -> ExpRhoType -> TcM (HsExpr TcId)+isHsValArg :: HsArg tm ty -> Bool+isHsValArg (HsValArg {}) = True+isHsValArg (HsTypeArg {}) = False++type LHsExprArgIn = HsArg (LHsExpr GhcRn) (LHsWcType GhcRn)+type LHsExprArgOut = HsArg (LHsExpr GhcTcId) (LHsWcType GhcRn)++tcApp1 :: HsExpr GhcRn -- either HsApp or HsAppType+ -> ExpRhoType -> TcM (HsExpr GhcTcId) tcApp1 e res_ty = do { (wrap, fun, args) <- tcApp Nothing (noLoc e) [] res_ty ; return (mkHsWrap wrap $ unLoc $ foldl mk_hs_app fun args) } where- mk_hs_app f (Left a) = mkHsApp f a- mk_hs_app f (Right a) = mkHsAppTypeOut f a+ mk_hs_app f (HsValArg a) = mkHsApp f a+ mk_hs_app f (HsTypeArg a) = mkHsAppTypeOut f a tcApp :: Maybe SDoc -- like "The function `f' is applied to" -- or leave out to get exactly that message- -> LHsExpr Name -> [LHsExprArgIn] -- Function and args- -> ExpRhoType -> TcM (HsWrapper, LHsExpr TcId, [LHsExprArgOut])+ -> LHsExpr GhcRn -> [LHsExprArgIn] -- Function and args+ -> ExpRhoType -> TcM (HsWrapper, LHsExpr GhcTcId, [LHsExprArgOut]) -- (wrap, fun, args). For an ordinary function application, -- these should be assembled as (wrap (fun args)). -- But OpApp is slightly different, so that's why the caller@@ -1136,29 +1155,39 @@ tcApp m_herald orig_fun orig_args res_ty = go orig_fun orig_args where- go :: LHsExpr Name -> [LHsExprArgIn]- -> TcM (HsWrapper, LHsExpr TcId, [LHsExprArgOut])+ go :: LHsExpr GhcRn -> [LHsExprArgIn]+ -> TcM (HsWrapper, LHsExpr GhcTcId, [LHsExprArgOut]) go (L _ (HsPar e)) args = go e args- go (L _ (HsApp e1 e2)) args = go e1 (Left e2:args)- go (L _ (HsAppType e t)) args = go e (Right t:args)+ go (L _ (HsApp e1 e2)) args = go e1 (HsValArg e2:args)+ go (L _ (HsAppType e t)) args = go e (HsTypeArg t:args) go (L loc (HsVar (L _ fun))) args | fun `hasKey` tagToEnumKey- , count isLeft args == 1+ , count isHsValArg args == 1 = do { (wrap, expr, args) <- tcTagToEnum loc fun args res_ty ; return (wrap, expr, args) } | fun `hasKey` seqIdKey- , count isLeft args == 2+ , count isHsValArg args == 2 = do { (wrap, expr, args) <- tcSeq loc fun args res_ty ; return (wrap, expr, args) } - go (L loc (HsRecFld (Ambiguous lbl _))) args@(Left (L _ arg) : _)+ go (L loc (HsRecFld (Ambiguous lbl _))) args@(HsValArg (L _ arg) : _) | Just sig_ty <- obviousSig arg = do { sig_tc_ty <- tcHsSigWcType ExprSigCtxt sig_ty ; sel_name <- disambiguateSelector lbl sig_tc_ty ; go (L loc (HsRecFld (Unambiguous lbl sel_name))) args } + -- See Note [Visible type application for the empty list constructor]+ go (L loc (ExplicitList _ Nothing [])) [HsTypeArg ty_arg]+ = do { ty_arg' <- tcHsTypeApp ty_arg liftedTypeKind+ ; let list_ty = TyConApp listTyCon [ty_arg']+ ; _ <- tcSubTypeDS (OccurrenceOf nilDataConName) GenSigCtxt+ list_ty res_ty+ ; let expr :: LHsExpr GhcTcId+ expr = L loc $ ExplicitList ty_arg' Nothing []+ ; return (idHsWrapper, expr, []) }+ go fun args = do { -- Type-check the function ; (fun1, fun_sigma) <- tcInferFun fun@@ -1166,29 +1195,56 @@ ; (wrap_fun, args1, actual_res_ty) <- tcArgs fun fun_sigma orig args- (m_herald `orElse` mk_app_msg fun)+ (m_herald `orElse` mk_app_msg fun args) -- this is just like tcWrapResult, but the types don't line -- up to call that function ; wrap_res <- addFunResCtxt True (unLoc fun) actual_res_ty res_ty $ tcSubTypeDS_NC_O orig GenSigCtxt- (Just $ foldl mk_hs_app fun args)+ (Just $ unLoc $ foldl mk_hs_app fun args) actual_res_ty res_ty ; return (wrap_res, mkLHsWrap wrap_fun fun1, args1) } - mk_hs_app f (Left a) = mkHsApp f a- mk_hs_app f (Right a) = mkHsAppType f a+ mk_hs_app f (HsValArg a) = mkHsApp f a+ mk_hs_app f (HsTypeArg a) = mkHsAppType f a -mk_app_msg :: LHsExpr Name -> SDoc-mk_app_msg fun = sep [ text "The function" <+> quotes (ppr fun)- , text "is applied to"]+mk_app_msg :: LHsExpr GhcRn -> [LHsExprArgIn] -> SDoc+mk_app_msg fun args = sep [ text "The" <+> text what <+> quotes (ppr expr)+ , text "is applied to"]+ where+ what | null type_app_args = "function"+ | otherwise = "expression"+ -- Include visible type arguments (but not other arguments) in the herald.+ -- See Note [Herald for matchExpectedFunTys] in TcUnify.+ expr = mkHsAppTypes fun type_app_args+ type_app_args = [hs_ty | HsTypeArg hs_ty <- args] -mk_op_msg :: LHsExpr Name -> SDoc+mk_op_msg :: LHsExpr GhcRn -> SDoc mk_op_msg op = text "The operator" <+> quotes (ppr op) <+> text "takes" +{-+Note [Visible type application for the empty list constructor]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Getting the expression [] @Int to typecheck is slightly tricky since [] isn't+an ordinary data constructor. By default, when tcExpr typechecks a list+expression, it wraps the expression in a coercion, which gives it a type to the+effect of p[a]. It isn't until later zonking that the type becomes+forall a. [a], but that's too late for visible type application.++The workaround is to check for empty list expressions that have a visible type+argument in tcApp, and if so, directly typecheck [] @ty data constructor name.+This avoids the intermediate coercion and produces an expression of type [ty],+as one would intuitively expect.++Unfortunately, this workaround isn't terribly robust, since more involved+expressions such as (let in []) @Int won't work. Until a more elegant fix comes+along, however, this at least allows direct type application on [] to work,+which is better than before.+-}+ -----------------tcInferFun :: LHsExpr Name -> TcM (LHsExpr TcId, TcSigmaType)+tcInferFun :: LHsExpr GhcRn -> TcM (LHsExpr GhcTcId, TcSigmaType) -- Infer type of a function tcInferFun (L loc (HsVar (L _ name))) = do { (fun, ty) <- setSrcSpan loc (tcInferId name)@@ -1209,7 +1265,7 @@ ---------------- -- | Type-check the arguments to a function, possibly including visible type -- applications-tcArgs :: LHsExpr Name -- ^ The function itself (for err msgs only)+tcArgs :: LHsExpr GhcRn -- ^ The function itself (for err msgs only) -> TcSigmaType -- ^ the (uninstantiated) type of the function -> CtOrigin -- ^ the origin for the function's type -> [LHsExprArgIn] -- ^ the args@@ -1219,11 +1275,15 @@ tcArgs fun orig_fun_ty fun_orig orig_args herald = go [] 1 orig_fun_ty orig_args where- orig_arity = length orig_args+ -- Don't count visible type arguments when determining how many arguments+ -- an expression is given in an arity mismatch error, since visible type+ -- arguments reported as a part of the expression herald itself.+ -- See Note [Herald for matchExpectedFunTys] in TcUnify.+ orig_expr_args_arity = count isHsValArg orig_args go _ _ fun_ty [] = return (idHsWrapper, [], fun_ty) - go acc_args n fun_ty (Right hs_ty_arg:args)+ go acc_args n fun_ty (HsTypeArg hs_ty_arg : args) = do { (wrap1, upsilon_ty) <- topInstantiateInferred fun_orig fun_ty -- wrap1 :: fun_ty "->" upsilon_ty ; case tcSplitForAllTy_maybe upsilon_ty of@@ -1244,30 +1304,30 @@ insted_ty = substTyWithInScope in_scope [tv] [ty_arg] inner_ty -- NB: tv and ty_arg have the same kind, so this -- substitution is kind-respecting- ; traceTc "VTA" (vcat [ppr tv, ppr kind- , ppr ty_arg- , ppr (typeKind ty_arg)- , ppr insted_ty ])+ ; traceTc "VTA" (vcat [ppr tv, debugPprType kind+ , debugPprType ty_arg+ , debugPprType (typeKind ty_arg)+ , debugPprType insted_ty ]) ; (inner_wrap, args', res_ty) <- go acc_args (n+1) insted_ty args -- inner_wrap :: insted_ty "->" (map typeOf args') -> res_ty ; let inst_wrap = mkWpTyApps [ty_arg] ; return ( inner_wrap <.> inst_wrap <.> wrap1- , Right hs_ty_arg : args'+ , HsTypeArg hs_ty_arg : args' , res_ty ) } _ -> ty_app_err upsilon_ty hs_ty_arg } - go acc_args n fun_ty (Left arg : args)+ go acc_args n fun_ty (HsValArg arg : args) = do { (wrap, [arg_ty], res_ty)- <- matchActualFunTysPart herald fun_orig (Just fun) 1 fun_ty- acc_args orig_arity+ <- matchActualFunTysPart herald fun_orig (Just (unLoc fun)) 1 fun_ty+ acc_args orig_expr_args_arity -- wrap :: fun_ty "->" arg_ty -> res_ty ; arg' <- tcArg fun arg arg_ty n ; (inner_wrap, args', inner_res_ty) <- go (arg_ty : acc_args) (n+1) res_ty args -- inner_wrap :: res_ty "->" (map typeOf args') -> inner_res_ty ; return ( mkWpFun idHsWrapper inner_wrap arg_ty res_ty doc <.> wrap- , Left arg' : args'+ , HsValArg arg' : args' , inner_res_ty ) } where doc = text "When checking the" <+> speakNth n <+>@@ -1309,16 +1369,16 @@ -} -----------------tcArg :: LHsExpr Name -- The function (for error messages)- -> LHsExpr Name -- Actual arguments+tcArg :: LHsExpr GhcRn -- The function (for error messages)+ -> LHsExpr GhcRn -- Actual arguments -> TcRhoType -- expected arg type -> Int -- # of argument- -> TcM (LHsExpr TcId) -- Resulting argument+ -> TcM (LHsExpr GhcTcId) -- Resulting argument tcArg fun arg ty arg_no = addErrCtxt (funAppCtxt fun arg arg_no) $ tcPolyExprNC arg ty -----------------tcTupArgs :: [LHsTupArg Name] -> [TcSigmaType] -> TcM [LHsTupArg TcId]+tcTupArgs :: [LHsTupArg GhcRn] -> [TcSigmaType] -> TcM [LHsTupArg GhcTcId] tcTupArgs args tys = ASSERT( equalLength args tys ) mapM go (args `zip` tys) where@@ -1329,11 +1389,11 @@ --------------------------- -- See TcType.SyntaxOpType also for commentary tcSyntaxOp :: CtOrigin- -> SyntaxExpr Name+ -> SyntaxExpr GhcRn -> [SyntaxOpType] -- ^ shape of syntax operator arguments -> ExpRhoType -- ^ overall result type -> ([TcSigmaType] -> TcM a) -- ^ Type check any arguments- -> TcM (a, SyntaxExpr TcId)+ -> TcM (a, SyntaxExpr GhcTcId) -- ^ Typecheck a syntax operator -- The operator is always a variable at this stage (i.e. renamer output) tcSyntaxOp orig expr arg_tys res_ty@@ -1342,11 +1402,11 @@ -- | Slightly more general version of 'tcSyntaxOp' that allows the caller -- to specify the shape of the result of the syntax operator tcSyntaxOpGen :: CtOrigin- -> SyntaxExpr Name+ -> SyntaxExpr GhcRn -> [SyntaxOpType] -> SyntaxOpType -> ([TcSigmaType] -> TcM a)- -> TcM (a, SyntaxExpr TcId)+ -> TcM (a, SyntaxExpr GhcTcId) tcSyntaxOpGen orig (SyntaxExpr { syn_expr = HsVar (L _ op) }) arg_tys res_ty thing_inside = do { (expr, sigma) <- tcInferId op@@ -1447,7 +1507,7 @@ -- and a wrapper to be applied to the overall expression tcSynArgA orig sigma_ty arg_shapes res_shape thing_inside = do { (match_wrapper, arg_tys, res_ty)- <- matchActualFunTys herald orig noThing (length arg_shapes) sigma_ty+ <- matchActualFunTys herald orig Nothing (length arg_shapes) sigma_ty -- match_wrapper :: sigma_ty "->" (arg_tys -> res_ty) ; ((result, res_wrapper), arg_wrappers) <- tc_syn_args_e arg_tys arg_shapes $ \ arg_results ->@@ -1527,7 +1587,7 @@ * * ********************************************************************* -} -tcExprSig :: LHsExpr Name -> TcIdSigInfo -> TcM (LHsExpr TcId, TcType)+tcExprSig :: LHsExpr GhcRn -> TcIdSigInfo -> TcM (LHsExpr GhcTcId, TcType) tcExprSig expr (CompleteSig { sig_bndr = poly_id, sig_loc = loc }) = setSrcSpan loc $ -- Sets the location for the implication constraint do { (tv_prs, theta, tau) <- tcInstType tcInstSkolTyVars poly_id@@ -1570,7 +1630,7 @@ my_sigma = mkForAllTys binders (mkPhiTy my_theta tau) ; wrap <- if inferred_sigma `eqType` my_sigma -- NB: eqType ignores vis. then return idHsWrapper -- Fast path; also avoids complaint when we infer- -- an ambiguouse type and have AllowAmbiguousType+ -- an ambiguous type and have AllowAmbiguousType -- e..g infer x :: forall a. F a -> Int else tcSubType_NC ExprSigCtxt inferred_sigma my_sigma @@ -1616,26 +1676,26 @@ * * ********************************************************************* -} -tcCheckId :: Name -> ExpRhoType -> TcM (HsExpr TcId)+tcCheckId :: Name -> ExpRhoType -> TcM (HsExpr GhcTcId) tcCheckId name res_ty = do { (expr, actual_res_ty) <- tcInferId name ; traceTc "tcCheckId" (vcat [ppr name, ppr actual_res_ty, ppr res_ty]) ; addFunResCtxt False (HsVar (noLoc name)) actual_res_ty res_ty $- tcWrapResultO (OccurrenceOf name) expr actual_res_ty res_ty }+ tcWrapResultO (OccurrenceOf name) (HsVar (noLoc name)) expr actual_res_ty res_ty } -tcCheckRecSelId :: AmbiguousFieldOcc Name -> ExpRhoType -> TcM (HsExpr TcId)-tcCheckRecSelId f@(Unambiguous (L _ lbl) _) res_ty+tcCheckRecSelId :: HsExpr GhcRn -> AmbiguousFieldOcc GhcRn -> ExpRhoType -> TcM (HsExpr GhcTcId)+tcCheckRecSelId rn_expr f@(Unambiguous (L _ lbl) _) res_ty = do { (expr, actual_res_ty) <- tcInferRecSelId f ; addFunResCtxt False (HsRecFld f) actual_res_ty res_ty $- tcWrapResultO (OccurrenceOfRecSel lbl) expr actual_res_ty res_ty }-tcCheckRecSelId (Ambiguous lbl _) res_ty+ tcWrapResultO (OccurrenceOfRecSel lbl) rn_expr expr actual_res_ty res_ty }+tcCheckRecSelId rn_expr (Ambiguous lbl _) res_ty = case tcSplitFunTy_maybe =<< checkingExpType_maybe res_ty of Nothing -> ambiguousSelector lbl Just (arg, _) -> do { sel_name <- disambiguateSelector lbl arg- ; tcCheckRecSelId (Unambiguous lbl sel_name) res_ty }+ ; tcCheckRecSelId rn_expr (Unambiguous lbl sel_name) res_ty } -------------------------tcInferRecSelId :: AmbiguousFieldOcc Name -> TcM (HsExpr TcId, TcRhoType)+tcInferRecSelId :: AmbiguousFieldOcc GhcRn -> TcM (HsExpr GhcTcId, TcRhoType) tcInferRecSelId (Unambiguous (L _ lbl) sel) = do { (expr', ty) <- tc_infer_id lbl sel ; return (expr', ty) }@@ -1643,7 +1703,7 @@ = ambiguousSelector lbl -------------------------tcInferId :: Name -> TcM (HsExpr TcId, TcSigmaType)+tcInferId :: Name -> TcM (HsExpr GhcTcId, TcSigmaType) -- Look up an occurrence of an Id -- Do not instantiate its type tcInferId id_name@@ -1662,7 +1722,7 @@ ; traceTc "tcInferId" (ppr id_name <+> dcolon <+> ppr ty) ; return (expr, ty) } -tc_infer_assert :: Name -> TcM (HsExpr TcId, TcSigmaType)+tc_infer_assert :: Name -> TcM (HsExpr GhcTcId, TcSigmaType) -- Deal with an occurrence of 'assert' -- See Note [Adding the implicit parameter to 'assert'] tc_infer_assert assert_name@@ -1672,7 +1732,7 @@ ; return (mkHsWrap wrap (HsVar (noLoc assert_error_id)), id_rho) } -tc_infer_id :: RdrName -> Name -> TcM (HsExpr TcId, TcSigmaType)+tc_infer_id :: RdrName -> Name -> TcM (HsExpr GhcTcId, TcSigmaType) tc_infer_id lbl id_name = do { thing <- tcLookup id_name ; case thing of@@ -1722,7 +1782,7 @@ | otherwise = return () -tcUnboundId :: UnboundVar -> ExpRhoType -> TcM (HsExpr TcId)+tcUnboundId :: HsExpr GhcRn -> UnboundVar -> ExpRhoType -> TcM (HsExpr GhcTcId) -- Typecheck an occurrence of an unbound Id -- -- Some of these started life as a true expression hole "_".@@ -1731,7 +1791,7 @@ -- We turn all of them into HsVar, since HsUnboundVar can't contain an -- Id; and indeed the evidence for the CHoleCan does bind it, so it's -- not unbound any more!-tcUnboundId unbound res_ty+tcUnboundId rn_expr unbound res_ty = do { ty <- newOpenFlexiTyVarTy -- Allow Int# etc (Trac #12531) ; let occ = unboundVarOcc unbound ; name <- newSysName occ@@ -1743,7 +1803,7 @@ , ctev_loc = loc} , cc_hole = ExprHole unbound } ; emitInsoluble can- ; tcWrapResultO (UnboundOccurrenceOf occ) (HsVar (noLoc ev)) ty res_ty }+ ; tcWrapResultO (UnboundOccurrenceOf occ) rn_expr (HsVar (noLoc ev)) ty res_ty } {-@@ -1797,14 +1857,14 @@ -} tcSeq :: SrcSpan -> Name -> [LHsExprArgIn]- -> ExpRhoType -> TcM (HsWrapper, LHsExpr TcId, [LHsExprArgOut])+ -> ExpRhoType -> TcM (HsWrapper, LHsExpr GhcTcId, [LHsExprArgOut]) -- (seq e1 e2) :: res_ty -- We need a special typing rule because res_ty can be unboxed -- See Note [Typing rule for seq] tcSeq loc fun_name args res_ty = do { fun <- tcLookupId fun_name ; (arg1_ty, args1) <- case args of- (Right hs_ty_arg1 : args1)+ (HsTypeArg hs_ty_arg1 : args1) -> do { ty_arg1 <- tcHsTypeApp hs_ty_arg1 liftedTypeKind ; return (ty_arg1, args1) } @@ -1812,40 +1872,40 @@ ; return (arg_ty1, args) } ; (arg1, arg2, arg2_exp_ty) <- case args1 of- [Right hs_ty_arg2, Left term_arg1, Left term_arg2]+ [HsTypeArg hs_ty_arg2, HsValArg term_arg1, HsValArg term_arg2] -> do { arg2_kind <- newOpenTypeKind ; ty_arg2 <- tcHsTypeApp hs_ty_arg2 arg2_kind -- see Note [Typing rule for seq] ; _ <- tcSubTypeDS (OccurrenceOf fun_name) GenSigCtxt ty_arg2 res_ty ; return (term_arg1, term_arg2, mkCheckExpType ty_arg2) }- [Left term_arg1, Left term_arg2]+ [HsValArg term_arg1, HsValArg term_arg2] -> return (term_arg1, term_arg2, res_ty) _ -> too_many_args "seq" args ; arg1' <- tcMonoExpr arg1 (mkCheckExpType arg1_ty) ; arg2' <- tcMonoExpr arg2 arg2_exp_ty ; res_ty <- readExpType res_ty -- by now, it's surely filled in- ; let fun' = L loc (HsWrap ty_args (HsVar (L loc fun)))+ ; let fun' = L loc (mkHsWrap ty_args (HsVar (L loc fun))) ty_args = WpTyApp res_ty <.> WpTyApp arg1_ty- ; return (idHsWrapper, fun', [Left arg1', Left arg2']) }+ ; return (idHsWrapper, fun', [HsValArg arg1', HsValArg arg2']) } tcTagToEnum :: SrcSpan -> Name -> [LHsExprArgIn] -> ExpRhoType- -> TcM (HsWrapper, LHsExpr TcId, [LHsExprArgOut])+ -> TcM (HsWrapper, LHsExpr GhcTcId, [LHsExprArgOut]) -- tagToEnum# :: forall a. Int# -> a -- See Note [tagToEnum#] Urgh! tcTagToEnum loc fun_name args res_ty = do { fun <- tcLookupId fun_name ; arg <- case args of- [Right hs_ty_arg, Left term_arg]+ [HsTypeArg hs_ty_arg, HsValArg term_arg] -> do { ty_arg <- tcHsTypeApp hs_ty_arg liftedTypeKind ; _ <- tcSubTypeDS (OccurrenceOf fun_name) GenSigCtxt ty_arg res_ty -- other than influencing res_ty, we just -- don't care about a type arg passed in. -- So drop the evidence. ; return term_arg }- [Left term_arg] -> do { _ <- expTypeToType res_ty- ; return term_arg }+ [HsValArg term_arg] -> do { _ <- expTypeToType res_ty+ ; return term_arg } _ -> too_many_args "tagToEnum#" args ; res_ty <- readExpType res_ty@@ -1867,10 +1927,10 @@ (mk_error ty' doc2) ; arg' <- tcMonoExpr arg (mkCheckExpType intPrimTy)- ; let fun' = L loc (HsWrap (WpTyApp rep_ty) (HsVar (L loc fun)))+ ; let fun' = L loc (mkHsWrap (WpTyApp rep_ty) (HsVar (L loc fun))) rep_ty = mkTyConApp rep_tc rep_args - ; return (mkWpCastR (mkTcSymCo coi), fun', [Left arg']) }+ ; return (mkWpCastR (mkTcSymCo coi), fun', [HsValArg arg']) } -- coi is a Representational coercion where doc1 = vcat [ text "Specify the type by giving a type signature"@@ -1889,8 +1949,8 @@ hang (text "Too many type arguments to" <+> text fun <> colon) 2 (sep (map pp args)) where- pp (Left e) = ppr e- pp (Right (HsWC { hswc_body = L _ t })) = pprParendHsType t+ pp (HsValArg e) = ppr e+ pp (HsTypeArg (HsWC { hswc_body = L _ t })) = pprHsType t {-@@ -2133,9 +2193,9 @@ -- Disambiguate the fields in a record update. -- See Note [Disambiguating record fields]-disambiguateRecordBinds :: LHsExpr Name -> TcRhoType- -> [LHsRecUpdField Name] -> ExpRhoType- -> TcM [LHsRecField' (AmbiguousFieldOcc Id) (LHsExpr Name)]+disambiguateRecordBinds :: LHsExpr GhcRn -> TcRhoType+ -> [LHsRecUpdField GhcRn] -> ExpRhoType+ -> TcM [LHsRecField' (AmbiguousFieldOcc GhcTc) (LHsExpr GhcRn)] disambiguateRecordBinds record_expr record_rho rbnds res_ty -- Are all the fields unambiguous? = case mapM isUnambiguous rbnds of@@ -2153,13 +2213,13 @@ ; checkNoErrs $ mapM (pickParent p) rbnds_with_parents } where -- Extract the selector name of a field update if it is unambiguous- isUnambiguous :: LHsRecUpdField Name -> Maybe (LHsRecUpdField Name, Name)+ isUnambiguous :: LHsRecUpdField GhcRn -> Maybe (LHsRecUpdField GhcRn,Name) isUnambiguous x = case unLoc (hsRecFieldLbl (unLoc x)) of Unambiguous _ sel_name -> Just (x, sel_name) Ambiguous{} -> Nothing -- Look up the possible parents and selector GREs for each field- getUpdFieldsParents :: TcM [(LHsRecUpdField Name+ getUpdFieldsParents :: TcM [(LHsRecUpdField GhcRn , [(RecSelParent, GlobalRdrElt)])] getUpdFieldsParents = fmap (zip rbnds) $ mapM@@ -2196,8 +2256,8 @@ -- r { x = e } :: T -- where T does not have field x. pickParent :: RecSelParent- -> (LHsRecUpdField Name, [(RecSelParent, GlobalRdrElt)])- -> TcM (LHsRecField' (AmbiguousFieldOcc Id) (LHsExpr Name))+ -> (LHsRecUpdField GhcRn, [(RecSelParent, GlobalRdrElt)])+ -> TcM (LHsRecField' (AmbiguousFieldOcc GhcTc) (LHsExpr GhcRn)) pickParent p (upd, xs) = case lookup p xs of -- Phew! The parent is valid for this field.@@ -2217,8 +2277,8 @@ -- Given a (field update, selector name) pair, look up the -- selector to give a field update with an unambiguous Id- lookupSelector :: (LHsRecUpdField Name, Name)- -> TcM (LHsRecField' (AmbiguousFieldOcc Id) (LHsExpr Name))+ lookupSelector :: (LHsRecUpdField GhcRn, Name)+ -> TcM (LHsRecField' (AmbiguousFieldOcc GhcTc) (LHsExpr GhcRn)) lookupSelector (L l upd, n) = do { i <- tcLookupId n ; let L loc af = hsRecFieldLbl upd@@ -2259,7 +2319,7 @@ -- A type signature on the argument of an ambiguous record selector or -- the record expression in an update must be "obvious", i.e. the -- outermost constructor ignoring parentheses.-obviousSig :: HsExpr Name -> Maybe (LHsSigWcType Name)+obviousSig :: HsExpr GhcRn -> Maybe (LHsSigWcType GhcRn) obviousSig (ExprWithTySig _ ty) = Just ty obviousSig (HsPar p) = obviousSig (unLoc p) obviousSig _ = Nothing@@ -2286,18 +2346,18 @@ tcRecordBinds :: ConLike -> [TcType] -- Expected type for each field- -> HsRecordBinds Name- -> TcM (HsRecordBinds TcId)+ -> HsRecordBinds GhcRn+ -> TcM (HsRecordBinds GhcTcId) tcRecordBinds con_like arg_tys (HsRecFields rbinds dd) = do { mb_binds <- mapM do_bind rbinds ; return (HsRecFields (catMaybes mb_binds) dd) } where- fields = map flLabel $ conLikeFieldLabels con_like+ fields = map flSelector $ conLikeFieldLabels con_like flds_w_tys = zipEqual "tcRecordBinds" fields arg_tys - do_bind :: LHsRecField Name (LHsExpr Name)- -> TcM (Maybe (LHsRecField TcId (LHsExpr TcId)))+ do_bind :: LHsRecField GhcRn (LHsExpr GhcRn)+ -> TcM (Maybe (LHsRecField GhcTcId (LHsExpr GhcTcId))) do_bind (L l fld@(HsRecField { hsRecFieldLbl = f , hsRecFieldArg = rhs })) @@ -2310,14 +2370,16 @@ tcRecordUpd :: ConLike -> [TcType] -- Expected type for each field- -> [LHsRecField' (AmbiguousFieldOcc Id) (LHsExpr Name)]- -> TcM [LHsRecUpdField TcId]+ -> [LHsRecField' (AmbiguousFieldOcc GhcTc) (LHsExpr GhcRn)]+ -> TcM [LHsRecUpdField GhcTcId] tcRecordUpd con_like arg_tys rbinds = fmap catMaybes $ mapM do_bind rbinds where- flds_w_tys = zipEqual "tcRecordUpd" (map flLabel $ conLikeFieldLabels con_like) arg_tys+ fields = map flSelector $ conLikeFieldLabels con_like+ flds_w_tys = zipEqual "tcRecordUpd" fields arg_tys - do_bind :: LHsRecField' (AmbiguousFieldOcc Id) (LHsExpr Name) -> TcM (Maybe (LHsRecUpdField TcId))+ do_bind :: LHsRecField' (AmbiguousFieldOcc GhcTc) (LHsExpr GhcRn)+ -> TcM (Maybe (LHsRecUpdField GhcTcId)) do_bind (L l fld@(HsRecField { hsRecFieldLbl = L loc af , hsRecFieldArg = rhs })) = do { let lbl = rdrNameAmbiguousFieldOcc af@@ -2333,10 +2395,11 @@ (selectorFieldOcc (unLoc f'))) , hsRecFieldArg = rhs' }))) } -tcRecordField :: ConLike -> Assoc FieldLabelString Type -> LFieldOcc Name -> LHsExpr Name- -> TcM (Maybe (LFieldOcc Id, LHsExpr Id))+tcRecordField :: ConLike -> Assoc Name Type+ -> LFieldOcc GhcRn -> LHsExpr GhcRn+ -> TcM (Maybe (LFieldOcc GhcTc, LHsExpr GhcTc)) tcRecordField con_like flds_w_tys (L loc (FieldOcc lbl sel_name)) rhs- | Just field_ty <- assocMaybe flds_w_tys field_lbl+ | Just field_ty <- assocMaybe flds_w_tys sel_name = addErrCtxt (fieldCtxt field_lbl) $ do { rhs' <- tcPolyExprNC rhs field_ty ; let field_id = mkUserLocal (nameOccName sel_name)@@ -2354,24 +2417,27 @@ field_lbl = occNameFS $ rdrNameOcc (unLoc lbl) -checkMissingFields :: ConLike -> HsRecordBinds Name -> TcM ()+checkMissingFields :: ConLike -> HsRecordBinds GhcRn -> TcM () checkMissingFields con_like rbinds | null field_labels -- Not declared as a record; -- But C{} is still valid if no strict fields = if any isBanged field_strs then -- Illegal if any arg is strict addErrTc (missingStrictFields con_like [])- else- return ()+ else do+ warn <- woptM Opt_WarnMissingFields+ when (warn && notNull field_strs && null field_labels)+ (warnTc (Reason Opt_WarnMissingFields) True+ (missingFields con_like [])) | otherwise = do -- A record unless (null missing_s_fields) (addErrTc (missingStrictFields con_like missing_s_fields)) warn <- woptM Opt_WarnMissingFields- unless (not (warn && notNull missing_ns_fields))- (warnTc (Reason Opt_WarnMissingFields) True- (missingFields con_like missing_ns_fields))+ when (warn && notNull missing_ns_fields)+ (warnTc (Reason Opt_WarnMissingFields) True+ (missingFields con_like missing_ns_fields)) where missing_s_fields@@ -2406,10 +2472,10 @@ Boring and alphabetical: -} -addExprErrCtxt :: LHsExpr Name -> TcM a -> TcM a+addExprErrCtxt :: LHsExpr GhcRn -> TcM a -> TcM a addExprErrCtxt expr = addErrCtxt (exprCtxt expr) -exprCtxt :: LHsExpr Name -> SDoc+exprCtxt :: LHsExpr GhcRn -> SDoc exprCtxt expr = hang (text "In the expression:") 2 (ppr expr) @@ -2418,7 +2484,7 @@ = text "In the" <+> quotes (ppr field_name) <+> ptext (sLit "field of a record") addFunResCtxt :: Bool -- There is at least one argument- -> HsExpr Name -> TcType -> ExpRhoType+ -> HsExpr GhcRn -> TcType -> ExpRhoType -> TcM a -> TcM a -- When we have a mis-match in the return type of a function -- try to give a helpful message about too many/few arguments@@ -2440,7 +2506,11 @@ do { dumping <- doptM Opt_D_dump_tc_trace ; MASSERT( dumping ) ; newFlexiTyVarTy liftedTypeKind }- ; let (_, _, fun_tau) = tcSplitSigmaTy fun_res'+ ; let -- See Note [Splitting nested sigma types in mismatched+ -- function types]+ (_, _, fun_tau) = tcSplitNestedSigmaTys fun_res'+ -- No need to call tcSplitNestedSigmaTys here, since env_ty is+ -- an ExpRhoTy, i.e., it's already deeply instantiated. (_, _, env_tau) = tcSplitSigmaTy env' (args_fun, res_fun) = tcSplitFunTys fun_tau (args_env, res_env) = tcSplitFunTys env_tau@@ -2467,6 +2537,44 @@ Just (tc, _) -> isAlgTyCon tc Nothing -> False +{-+Note [Splitting nested sigma types in mismatched function types]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When one applies a function to too few arguments, GHC tries to determine this+fact if possible so that it may give a helpful error message. It accomplishes+this by checking if the type of the applied function has more argument types+than supplied arguments.++Previously, GHC computed the number of argument types through tcSplitSigmaTy.+This is incorrect in the face of nested foralls, however! This caused Trac+#13311, for instance:++ f :: forall a. (Monoid a) => forall b. (Monoid b) => Maybe a -> Maybe b++If one uses `f` like so:++ do { f; putChar 'a' }++Then tcSplitSigmaTy will decompose the type of `f` into:++ Tyvars: [a]+ Context: (Monoid a)+ Argument types: []+ Return type: forall b. Monoid b => Maybe a -> Maybe b++That is, it will conclude that there are *no* argument types, and since `f`+was given no arguments, it won't print a helpful error message. On the other+hand, tcSplitNestedSigmaTys correctly decomposes `f`'s type down to:++ Tyvars: [a, b]+ Context: (Monoid a, Monoid b)+ Argument types: [Maybe a]+ Return type: Maybe b++So now GHC recognizes that `f` has one more argument type than it was actually+provided.+-}+ badFieldTypes :: [(FieldLabelString,TcType)] -> SDoc badFieldTypes prs = hang (text "Record update for insufficiently polymorphic field"@@ -2474,7 +2582,8 @@ 2 (vcat [ ppr f <+> dcolon <+> ppr ty | (f,ty) <- prs ]) badFieldsUpd- :: [LHsRecField' (AmbiguousFieldOcc Id) (LHsExpr Name)] -- Field names that don't belong to a single datacon+ :: [LHsRecField' (AmbiguousFieldOcc GhcTc) (LHsExpr GhcRn)]+ -- Field names that don't belong to a single datacon -> [ConLike] -- Data cons of the type which the first field name belongs to -> SDoc badFieldsUpd rbinds data_cons@@ -2589,12 +2698,16 @@ missingFields :: ConLike -> [FieldLabelString] -> SDoc missingFields con fields- = text "Fields of" <+> quotes (ppr con) <+> ptext (sLit "not initialised:")- <+> pprWithCommas ppr fields+ = header <> rest+ where+ rest | null fields = Outputable.empty+ | otherwise = colon <+> pprWithCommas ppr fields+ header = text "Fields of" <+> quotes (ppr con) <+>+ text "not initialised" -- callCtxt fun args = text "In the call" <+> parens (ppr (foldl mkHsApp fun args)) -noPossibleParents :: [LHsRecUpdField Name] -> SDoc+noPossibleParents :: [LHsRecUpdField GhcRn] -> SDoc noPossibleParents rbinds = hang (text "No type has all these fields:") 2 (pprQuotedList fields)
typecheck/TcExpr.hs-boot view
@@ -1,40 +1,41 @@ module TcExpr where+import Name import HsSyn ( HsExpr, LHsExpr, SyntaxExpr )-import Name ( Name ) import TcType ( TcRhoType, TcSigmaType, SyntaxOpType, ExpType, ExpRhoType )-import TcRnTypes( TcM, TcId, CtOrigin )+import TcRnTypes( TcM, CtOrigin )+import HsExtension ( GhcRn, GhcTcId ) tcPolyExpr ::- LHsExpr Name+ LHsExpr GhcRn -> TcSigmaType- -> TcM (LHsExpr TcId)+ -> TcM (LHsExpr GhcTcId) tcMonoExpr, tcMonoExprNC ::- LHsExpr Name+ LHsExpr GhcRn -> ExpRhoType- -> TcM (LHsExpr TcId)+ -> TcM (LHsExpr GhcTcId) tcInferSigma, tcInferSigmaNC ::- LHsExpr Name- -> TcM (LHsExpr TcId, TcSigmaType)+ LHsExpr GhcRn+ -> TcM (LHsExpr GhcTcId, TcSigmaType) tcInferRho ::- LHsExpr Name- -> TcM (LHsExpr TcId, TcRhoType)+ LHsExpr GhcRn+ -> TcM (LHsExpr GhcTcId, TcRhoType) tcSyntaxOp :: CtOrigin- -> SyntaxExpr Name+ -> SyntaxExpr GhcRn -> [SyntaxOpType] -- ^ shape of syntax operator arguments -> ExpType -- ^ overall result type -> ([TcSigmaType] -> TcM a) -- ^ Type check any arguments- -> TcM (a, SyntaxExpr TcId)+ -> TcM (a, SyntaxExpr GhcTcId) tcSyntaxOpGen :: CtOrigin- -> SyntaxExpr Name+ -> SyntaxExpr GhcRn -> [SyntaxOpType] -> SyntaxOpType -> ([TcSigmaType] -> TcM a)- -> TcM (a, SyntaxExpr TcId)+ -> TcM (a, SyntaxExpr GhcTcId) -tcCheckId :: Name -> ExpRhoType -> TcM (HsExpr TcId)+tcCheckId :: Name -> ExpRhoType -> TcM (HsExpr GhcTcId)
typecheck/TcFlatten.hs view
@@ -4,11 +4,13 @@ FlattenMode(..), flatten, flattenManyNom, - unflatten,+ unflattenWanteds ) where #include "HsVersions.h" +import GhcPrelude+ import TcRnTypes import TcType import Type@@ -36,32 +38,51 @@ Note [The flattening story] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * A CFunEqCan is either of form- [G] <F xis> : F xis ~ fsk -- fsk is a FlatSkol- [W] x : F xis ~ fmv -- fmv is a unification variable,- -- but untouchable,- -- with MetaInfo = FlatMetaTv+ [G] <F xis> : F xis ~ fsk -- fsk is a FlatSkolTv+ [W] x : F xis ~ fmv -- fmv is a FlatMetaTv where x is the witness variable- fsk/fmv is a flatten skolem xis are function-free- CFunEqCans are always [Wanted], or [Given], never [Derived]+ fsk/fmv is a flatten skolem;+ it is always untouchable (level 0) - fmv untouchable just means that in a CTyVarEq, say,- fmv ~ Int- we do NOT unify fmv.+* CFunEqCans can have any flavour: [G], [W], [WD] or [D] * KEY INSIGHTS: - A given flatten-skolem, fsk, is known a-priori to be equal to- F xis (the LHS), with <F xis> evidence+ F xis (the LHS), with <F xis> evidence. The fsk is still a+ unification variable, but it is "owned" by its CFunEqCan, and+ is filled in (unflattened) only by unflattenGivens. - A unification flatten-skolem, fmv, stands for the as-yet-unknown- type to which (F xis) will eventually reduce+ type to which (F xis) will eventually reduce. It is filled in+ only by dischargeFmv. -* Inert set invariant: if F xis1 ~ fsk1, F xis2 ~ fsk2- then xis1 /= xis2- i.e. at most one CFunEqCan with a particular LHS+ - All fsk/fmv variables are "untouchable". To make it simple to test,+ we simply give them TcLevel=0. This means that in a CTyVarEq, say,+ fmv ~ Int+ we NEVER unify fmv. + - A unification flatten-skolems, fmv, ONLY gets unified when either+ a) The CFunEqCan takes a step, using an axiom+ b) By unflattenWanteds+ They are never unified in any other form of equality.+ For example [W] ffmv ~ Int is stuck; it does not unify with fmv.++* We *never* substitute in the RHS (i.e. the fsk/fmv) of a CFunEqCan.+ That would destroy the invariant about the shape of a CFunEqCan,+ and it would risk wanted/wanted interactions. The only way we+ learn information about fsk is when the CFunEqCan takes a step.++ However we *do* substitute in the LHS of a CFunEqCan (else it+ would never get to fire!)++* Unflattening:+ - We unflatten Givens when leaving their scope (see unflattenGivens)+ - We unflatten Wanteds at the end of each attempt to simplify the+ wanteds; see unflattenWanteds, called from solveSimpleWanteds.+ * Each canonical [G], [W], or [WD] CFunEqCan x : F xis ~ fsk/fmv has its own distinct evidence variable x and flatten-skolem fsk/fmv. Why? We make a fresh fsk/fmv when the constraint is born;@@ -70,8 +91,12 @@ In contrast a [D] CFunEqCan shares its fmv with its partner [W], but does not "own" it. If we reduce a [D] F Int ~ fmv, where say type instance F Int = ty, then we don't discharge fmv := ty.- Rather we simply generate [D] fmv ~ ty+ Rather we simply generate [D] fmv ~ ty (in TcInteract.reduce_top_fun_eq) +* Inert set invariant: if F xis1 ~ fsk1, F xis2 ~ fsk2+ then xis1 /= xis2+ i.e. at most one CFunEqCan with a particular LHS+ * Function applications can occur in the RHS of a CTyEqCan. No reason not allow this, and it reduces the amount of flattening that must occur. @@ -104,20 +129,6 @@ - Add new wanted to flat cache - Discharge x = F cos ; x2 -* Unification flatten-skolems, fmv, ONLY get unified when either- a) The CFunEqCan takes a step, using an axiom- b) During un-flattening- They are never unified in any other form of equality.- For example [W] ffmv ~ Int is stuck; it does not unify with fmv.--* We *never* substitute in the RHS (i.e. the fsk/fmv) of a CFunEqCan.- That would destroy the invariant about the shape of a CFunEqCan,- and it would risk wanted/wanted interactions. The only way we- learn information about fsk is when the CFunEqCan takes a step.-- However we *do* substitute in the LHS of a CFunEqCan (else it- would never get to fire!)- * [Interacting rule] (inert) [W] x1 : F tys ~ fmv1 (work item) [W] x2 : F tys ~ fmv2@@ -575,7 +586,7 @@ else runFlatM thing_inside (env { fe_mode = new_mode }) -- | Use when flattening kinds/kind coercions. See--- Note [No derived kind equalities] in TcCanonical+-- Note [No derived kind equalities] flattenKinds :: FlatM a -> FlatM a flattenKinds thing_inside = FlatM $ \env ->@@ -708,6 +719,18 @@ canonicaliser will emit an insoluble, in which case the unflattened version yields a better error message anyway.) +Note [No derived kind equalities]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We call flattenKinds in two places: in flatten_co (Note [Flattening coercions])+and in flattenTyVar. The latter case is easier to understand; flattenKinds is+used to flatten the kind of a flat (i.e. inert) tyvar. Flattening a kind+naturally produces a coercion. This coercion is then used in the flattened type.+However, danger lurks if the flattening flavour (that is, the fe_flavour of the+FlattenEnv) is Derived: the coercion might be bottom. (This can happen when+looks up a kindvar in the inert set only to find a Derived equality, with+no coercion.) The solution is simple: ensure that the fe_flavour is not derived+when flattening a kind. This is what flattenKinds does.+ -} {- *********************************************************************@@ -916,6 +939,9 @@ = do { (xi1,co1) <- flatten_one ty1 ; eq_rel <- getEqRel ; case (eq_rel, nextRole xi1) of+ -- We need nextRole here because although ty1 definitely+ -- isn't a TyConApp, xi1 might be.+ -- ToDo: but can such a substitution change roles?? (NomEq, _) -> flatten_rhs xi1 co1 NomEq (ReprEq, Nominal) -> flatten_rhs xi1 co1 NomEq (ReprEq, Representational) -> flatten_rhs xi1 co1 ReprEq@@ -1123,7 +1149,7 @@ -- flatten_exact_fam_app_fully lifts out the application to top level -- Postcondition: Coercion :: Xi ~ F tys flatten_fam_app tc tys -- Can be over-saturated- = ASSERT2( tyConArity tc <= length tys+ = ASSERT2( tys `lengthAtLeast` tyConArity tc , ppr tc $$ ppr (tyConArity tc) $$ ppr tys) -- Type functions are saturated -- The type function might be *over* saturated@@ -1317,10 +1343,9 @@ FTRNotFollowed -- Done -> do { let orig_kind = tyVarKind tv- ; (_new_kind, kind_co) <- setMode FM_SubstOnly $- flattenKinds $+ ; (_new_kind, kind_co) <- flattenKinds $ flatten_one orig_kind- ; let Pair _ zonked_kind = coercionKind kind_co+ ; let Pair _ zonked_kind = coercionKind kind_co -- NB: kind_co :: _new_kind ~ zonked_kind -- But zonked_kind is not necessarily the same as orig_kind -- because that may have filled-in metavars.@@ -1330,13 +1355,13 @@ -- See also Note [Flattening] -- An alternative would to use (zonkTcType orig_kind), -- but some simple measurements suggest that's a little slower- ; let tv' = setTyVarKind tv zonked_kind- tv_ty' = mkTyVarTy tv'- ty' = tv_ty' `mkCastTy` mkSymCo kind_co+ ; let tv' = setTyVarKind tv zonked_kind+ tv_ty' = mkTyVarTy tv'+ ty' = tv_ty' `mkCastTy` mkSymCo kind_co - ; role <- getRole- ; return (ty', mkReflCo role tv_ty'- `mkCoherenceLeftCo` mkSymCo kind_co) } }+ ; role <- getRole+ ; return (ty', mkReflCo role tv_ty'+ `mkCoherenceLeftCo` mkSymCo kind_co) } } flatten_tyvar1 :: TcTyVar -> FlatM FlattenTvResult -- "Flattening" a type variable means to apply the substitution to it@@ -1346,15 +1371,10 @@ -- See also the documentation for FlattenTvResult flatten_tyvar1 tv- | not (isTcTyVar tv) -- Happens when flatten under a (forall a. ty)- = return FTRNotFollowed- -- So ty contains references to the non-TcTyVar a-- | otherwise = do { mb_ty <- liftTcS $ isFilledMetaTyVar_maybe tv- ; role <- getRole ; case mb_ty of Just ty -> do { traceFlat "Following filled tyvar" (ppr tv <+> equals <+> ppr ty)+ ; role <- getRole ; return (FTRFollowed ty (mkReflCo role ty)) } ; Nothing -> do { traceFlat "Unfilled tyvar" (ppr tv) ; fr <- getFlavourRole@@ -1372,12 +1392,13 @@ ; case lookupDVarEnv ieqs tv of Just (ct:_) -- If the first doesn't work, -- the subsequent ones won't either- | CTyEqCan { cc_ev = ctev, cc_tyvar = tv, cc_rhs = rhs_ty } <- ct- , let ct_fr = ctEvFlavourRole ctev+ | CTyEqCan { cc_ev = ctev, cc_tyvar = tv+ , cc_rhs = rhs_ty, cc_eq_rel = ct_eq_rel } <- ct+ , let ct_fr = (ctEvFlavour ctev, ct_eq_rel) , ct_fr `eqCanRewriteFR` fr -- This is THE key call of eqCanRewriteFR -> do { traceFlat "Following inert tyvar" (ppr mode <+> ppr tv <+> equals <+> ppr rhs_ty $$ ppr ctev) ; let rewrite_co1 = mkSymCo (ctEvCoercion ctev)- rewrite_co = case (ctEvEqRel ctev, eq_rel) of+ rewrite_co = case (ct_eq_rel, eq_rel) of (ReprEq, _rel) -> ASSERT( _rel == ReprEq ) -- if this ASSERT fails, then -- eqCanRewriteFR answered incorrectly@@ -1476,8 +1497,8 @@ We must solve both! -} -unflatten :: Cts -> Cts -> TcS Cts-unflatten tv_eqs funeqs+unflattenWanteds :: Cts -> Cts -> TcS Cts+unflattenWanteds tv_eqs funeqs = do { tclvl <- getTcLevel ; traceTcS "Unflattening" $ braces $@@ -1506,10 +1527,7 @@ ; let all_flat = tv_eqs `andCts` funeqs ; traceTcS "Unflattening done" $ braces (pprCts all_flat) - -- Step 5: zonk the result- -- Motivation: makes them nice and ready for the next step- -- (see TcInteract.solveSimpleWanteds)- ; zonkSimples all_flat }+ ; return all_flat } where ---------------- unflatten_funeq :: Ct -> Cts -> TcS Cts
typecheck/TcForeign.hs view
@@ -13,6 +13,7 @@ -} {-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-} module TcForeign ( tcForeignImports@@ -32,6 +33,8 @@ #include "HsVersions.h" +import GhcPrelude+ import HsSyn import TcRnMonad@@ -224,11 +227,13 @@ ************************************************************************ -} -tcForeignImports :: [LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt)+tcForeignImports :: [LForeignDecl GhcRn]+ -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt) tcForeignImports decls = getHooked tcForeignImportsHook tcForeignImports' >>= ($ decls) -tcForeignImports' :: [LForeignDecl Name] -> TcM ([Id], [LForeignDecl Id], Bag GlobalRdrElt)+tcForeignImports' :: [LForeignDecl GhcRn]+ -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt) -- For the (Bag GlobalRdrElt) result, -- see Note [Newtype constructor usage in foreign declarations] tcForeignImports' decls@@ -236,7 +241,8 @@ filter isForeignImport decls ; return (ids, decls, unionManyBags gres) } -tcFImport :: LForeignDecl Name -> TcM (Id, LForeignDecl Id, Bag GlobalRdrElt)+tcFImport :: LForeignDecl GhcRn+ -> TcM (Id, LForeignDecl GhcTc, Bag GlobalRdrElt) tcFImport (L dloc fo@(ForeignImport { fd_name = L nloc nm, fd_sig_ty = hs_ty , fd_fi = imp_decl })) = setSrcSpan dloc $ addErrCtxt (foreignDeclCtxt fo) $@@ -362,13 +368,13 @@ ************************************************************************ -} -tcForeignExports :: [LForeignDecl Name]- -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt)+tcForeignExports :: [LForeignDecl GhcRn]+ -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt) tcForeignExports decls = getHooked tcForeignExportsHook tcForeignExports' >>= ($ decls) -tcForeignExports' :: [LForeignDecl Name]- -> TcM (LHsBinds TcId, [LForeignDecl TcId], Bag GlobalRdrElt)+tcForeignExports' :: [LForeignDecl GhcRn]+ -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt) -- For the (Bag GlobalRdrElt) result, -- see Note [Newtype constructor usage in foreign declarations] tcForeignExports' decls@@ -378,7 +384,8 @@ (b, f, gres2) <- setSrcSpan loc (tcFExport fe) return (b `consBag` binds, L loc f : fs, gres1 `unionBags` gres2) -tcFExport :: ForeignDecl Name -> TcM (LHsBind Id, ForeignDecl Id, Bag GlobalRdrElt)+tcFExport :: ForeignDecl GhcRn+ -> TcM (LHsBind GhcTc, ForeignDecl GhcTc, Bag GlobalRdrElt) tcFExport fo@(ForeignExport { fd_name = L loc nm, fd_sig_ty = hs_ty, fd_fe = spec }) = addErrCtxt (foreignDeclCtxt fo) $ do @@ -556,7 +563,7 @@ badCName target = sep [quotes (ppr target) <+> text "is not a valid C identifier"] -foreignDeclCtxt :: ForeignDecl Name -> SDoc+foreignDeclCtxt :: ForeignDecl GhcRn -> SDoc foreignDeclCtxt fo = hang (text "When checking declaration:") 2 (ppr fo)
typecheck/TcGenDeriv.hs view
@@ -14,6 +14,7 @@ {-# LANGUAGE CPP, ScopedTypeVariables #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-} module TcGenDeriv ( BagDerivStuff, DerivStuff(..),@@ -31,11 +32,13 @@ mkCoerceClassMethEqn, genAuxBinds, ordOpTbl, boxConTbl, litConTbl,- mkRdrFunBind, error_Expr+ mkRdrFunBind, mkRdrFunBindEC, mkRdrFunBindSE, error_Expr ) where #include "HsVersions.h" +import GhcPrelude+ import TcRnMonad import HsSyn import RdrName@@ -93,7 +96,7 @@ | DerivFamInst FamInst -- New type family instances -- New top-level auxiliary bindings- | DerivHsBind (LHsBind RdrName, LSig RdrName) -- Also used for SYB+ | DerivHsBind (LHsBind GhcPs, LSig GhcPs) -- Also used for SYB {-@@ -123,7 +126,7 @@ case (a1 `eqFloat#` a2) of r -> r for that particular test. -* If there are a lot of (more than en) nullary constructors, we emit a+* If there are a lot of (more than ten) nullary constructors, we emit a catch-all clause of the form: (==) a b = case (con2tag_Foo a) of { a# ->@@ -155,7 +158,7 @@ produced don't get through the typechecker. -} -gen_Eq_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)+gen_Eq_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff) gen_Eq_binds loc tycon = do dflags <- getDynFlags return (method_binds dflags, aux_binds)@@ -190,14 +193,10 @@ aux_binds | no_tag_match_cons = emptyBag | otherwise = unitBag $ DerivAuxBind $ DerivCon2Tag tycon - method_binds dflags = listToBag- [ eq_bind dflags- , ne_bind- ]- eq_bind dflags = mk_FunBind loc eq_RDR (map pats_etc pat_match_cons- ++ fall_through_eqn dflags)- ne_bind = mk_easy_FunBind loc ne_RDR [a_Pat, b_Pat] (- nlHsApp (nlHsVar not_RDR) (nlHsPar (nlHsVarApps eq_RDR [a_RDR, b_RDR])))+ method_binds dflags = unitBag (eq_bind dflags)+ eq_bind dflags = mkFunBindEC 2 loc eq_RDR (const true_Expr)+ (map pats_etc pat_match_cons+ ++ fall_through_eqn dflags) ------------------------------------------------------------------ pats_etc data_con@@ -310,7 +309,7 @@ OrdGT -> gt_RDR -------------ltResult :: OrdOp -> LHsExpr RdrName+ltResult :: OrdOp -> LHsExpr GhcPs -- Knowing a<b, what is the result for a `op` b? ltResult OrdCompare = ltTag_Expr ltResult OrdLT = true_Expr@@ -319,7 +318,7 @@ ltResult OrdGT = false_Expr -------------eqResult :: OrdOp -> LHsExpr RdrName+eqResult :: OrdOp -> LHsExpr GhcPs -- Knowing a=b, what is the result for a `op` b? eqResult OrdCompare = eqTag_Expr eqResult OrdLT = false_Expr@@ -328,7 +327,7 @@ eqResult OrdGT = false_Expr -------------gtResult :: OrdOp -> LHsExpr RdrName+gtResult :: OrdOp -> LHsExpr GhcPs -- Knowing a>b, what is the result for a `op` b? gtResult OrdCompare = gtTag_Expr gtResult OrdLT = false_Expr@@ -337,11 +336,11 @@ gtResult OrdGT = true_Expr -------------gen_Ord_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)+gen_Ord_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff) gen_Ord_binds loc tycon = do dflags <- getDynFlags return $ if null tycon_data_cons -- No data-cons => invoke bale-out case- then ( unitBag $ mk_FunBind loc compare_RDR []+ then ( unitBag $ mkFunBindEC 2 loc compare_RDR (const eqTag_Expr) [] , emptyBag) else ( unitBag (mkOrdOp dflags OrdCompare) `unionBags` other_ops dflags , aux_binds)@@ -379,14 +378,14 @@ (nullary_cons, non_nullary_cons) = partition isNullarySrcDataCon tycon_data_cons - mkOrdOp :: DynFlags -> OrdOp -> LHsBind RdrName+ mkOrdOp :: DynFlags -> OrdOp -> LHsBind GhcPs -- Returns a binding op a b = ... compares a and b according to op .... mkOrdOp dflags op = mk_easy_FunBind loc (ordMethRdr op) [a_Pat, b_Pat] (mkOrdOpRhs dflags op) - mkOrdOpRhs :: DynFlags -> OrdOp -> LHsExpr RdrName+ mkOrdOpRhs :: DynFlags -> OrdOp -> LHsExpr GhcPs mkOrdOpRhs dflags op -- RHS for comparing 'a' and 'b' according to op- | length nullary_cons <= 2 -- Two nullary or fewer, so use cases+ | nullary_cons `lengthAtMost` 2 -- Two nullary or fewer, so use cases = nlHsCase (nlHsVar a_RDR) $ map (mkOrdOpAlt dflags op) tycon_data_cons -- i.e. case a of { C1 x y -> case b of C1 x y -> ....compare x,y...@@ -402,7 +401,7 @@ mkOrdOpAlt :: DynFlags -> OrdOp -> DataCon- -> LMatch RdrName (LHsExpr RdrName)+ -> LMatch GhcPs (LHsExpr GhcPs) -- Make the alternative (Ki a1 a2 .. av -> mkOrdOpAlt dflags op data_con = mkHsCaseAlt (nlConVarPat data_con_RDR as_needed)@@ -450,7 +449,7 @@ tag = get_tag data_con tag_lit = noLoc (HsLit (HsIntPrim NoSourceText (toInteger tag))) - mkInnerEqAlt :: OrdOp -> DataCon -> LMatch RdrName (LHsExpr RdrName)+ mkInnerEqAlt :: OrdOp -> DataCon -> LMatch GhcPs (LHsExpr GhcPs) -- First argument 'a' known to be built with K -- Returns a case alternative Ki b1 b2 ... bv -> compare (a1,a2,...) with (b1,b2,...) mkInnerEqAlt op data_con@@ -460,14 +459,14 @@ data_con_RDR = getRdrName data_con bs_needed = take (dataConSourceArity data_con) bs_RDRs - mkTagCmp :: DynFlags -> OrdOp -> LHsExpr RdrName+ mkTagCmp :: DynFlags -> OrdOp -> LHsExpr GhcPs -- Both constructors known to be nullary- -- genreates (case data2Tag a of a# -> case data2Tag b of b# -> a# `op` b#+ -- generates (case data2Tag a of a# -> case data2Tag b of b# -> a# `op` b# mkTagCmp dflags op = untag_Expr dflags tycon[(a_RDR, ah_RDR),(b_RDR, bh_RDR)] $ unliftedOrdOp tycon intPrimTy op ah_RDR bh_RDR -mkCompareFields :: TyCon -> OrdOp -> [Type] -> LHsExpr RdrName+mkCompareFields :: TyCon -> OrdOp -> [Type] -> LHsExpr GhcPs -- Generates nested comparisons for (a1,a2...) against (b1,b2,...) -- where the ai,bi have the given types mkCompareFields tycon op tys@@ -499,7 +498,7 @@ b_expr = nlHsVar b (lt_op, _, eq_op, _, _) = primOrdOps "Ord" tycon ty -unliftedOrdOp :: TyCon -> Type -> OrdOp -> RdrName -> RdrName -> LHsExpr RdrName+unliftedOrdOp :: TyCon -> Type -> OrdOp -> RdrName -> RdrName -> LHsExpr GhcPs unliftedOrdOp tycon ty op a b = case op of OrdCompare -> unliftedCompare lt_op eq_op a_expr b_expr@@ -515,9 +514,10 @@ b_expr = nlHsVar b unliftedCompare :: RdrName -> RdrName- -> LHsExpr RdrName -> LHsExpr RdrName -- What to cmpare- -> LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName -- Three results- -> LHsExpr RdrName+ -> LHsExpr GhcPs -> LHsExpr GhcPs -- What to cmpare+ -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs+ -- Three results+ -> LHsExpr GhcPs -- Return (if a < b then lt else if a == b then eq else gt) unliftedCompare lt_op eq_op a_expr b_expr lt eq gt = nlHsIf (ascribeBool $ genPrimOpApp a_expr lt_op b_expr) lt $@@ -528,7 +528,7 @@ where ascribeBool e = nlExprWithTySig e boolTy -nlConWildPat :: DataCon -> LPat RdrName+nlConWildPat :: DataCon -> LPat GhcPs -- The pattern (K {}) nlConWildPat con = noLoc (ConPatIn (noLoc (getRdrName con)) (RecCon (HsRecFields { rec_flds = []@@ -577,7 +577,7 @@ For @enumFromTo@ and @enumFromThenTo@, we use the default methods. -} -gen_Enum_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)+gen_Enum_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff) gen_Enum_binds loc tycon = do dflags <- getDynFlags return (method_binds dflags, aux_binds)@@ -612,8 +612,9 @@ nlHsVarApps intDataCon_RDR [ah_RDR]]) (illegal_Expr "pred" occ_nm "tried to take `pred' of first tag in enumeration") (nlHsApp (nlHsVar (tag2con_RDR dflags tycon))- (nlHsApps plus_RDR [nlHsVarApps intDataCon_RDR [ah_RDR],- nlHsLit (HsInt NoSourceText (-1))]))+ (nlHsApps plus_RDR+ [ nlHsVarApps intDataCon_RDR [ah_RDR]+ , nlHsLit (HsInt def (mkIntegralLit (-1 :: Int)))])) to_enum dflags = mk_easy_FunBind loc toEnum_RDR [a_Pat] $@@ -659,7 +660,7 @@ ************************************************************************ -} -gen_Bounded_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)+gen_Bounded_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff) gen_Bounded_binds loc tycon | isEnumerationTyCon tycon = (listToBag [ min_bound_enum, max_bound_enum ], emptyBag)@@ -746,7 +747,7 @@ (p.~147). -} -gen_Ix_binds :: SrcSpan -> TyCon -> TcM (LHsBinds RdrName, BagDerivStuff)+gen_Ix_binds :: SrcSpan -> TyCon -> TcM (LHsBinds GhcPs, BagDerivStuff) gen_Ix_binds loc tycon = do dflags <- getDynFlags@@ -900,9 +901,7 @@ -- Record construction binds even more tightly than application do expectP (Ident "T1") expectP (Punc '{')- expectP (Ident "f1")- expectP (Punc '=')- x <- ReadP.reset Read.readPrec+ x <- Read.readField "f1" (ReadP.reset readPrec) expectP (Punc '}') return (T1 { f1 = x })) +++@@ -946,7 +945,8 @@ we want to be able to parse (Left 3) just fine. -} -gen_Read_binds :: (Name -> Fixity) -> SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)+gen_Read_binds :: (Name -> Fixity) -> SrcSpan -> TyCon+ -> (LHsBinds GhcPs, BagDerivStuff) gen_Read_binds get_fixity loc tycon = (listToBag [read_prec, default_readlist, default_readlistprec], emptyBag)@@ -962,11 +962,15 @@ data_cons = tyConDataCons tycon (nullary_cons, non_nullary_cons) = partition isNullarySrcDataCon data_cons - read_prec = mkHsVarBind loc readPrec_RDR- (nlHsApp (nlHsVar parens_RDR) read_cons)+ read_prec = mkHsVarBind loc readPrec_RDR rhs+ where+ rhs | null data_cons -- See Note [Read for empty data types]+ = nlHsVar pfail_RDR+ | otherwise+ = nlHsApp (nlHsVar parens_RDR)+ (foldr1 mk_alt (read_nullary_cons +++ read_non_nullary_cons)) - read_cons | null data_cons = nlHsVar pfail_RDR -- See Note [Read for empty data types]- | otherwise = foldr1 mk_alt (read_nullary_cons ++ read_non_nullary_cons) read_non_nullary_cons = map read_non_nullary_con non_nullary_cons read_nullary_cons@@ -1031,7 +1035,7 @@ labels = map flLabel $ dataConFieldLabels data_con dc_nm = getName data_con is_infix = dataConIsInfix data_con- is_record = length labels > 0+ is_record = labels `lengthExceeds` 0 as_needed = take con_arity as_RDRs read_args = zipWithEqual "gen_Read_binds" read_arg as_needed (dataConOrigArgTys data_con) (read_a1:read_a2:_) = read_args@@ -1067,21 +1071,28 @@ read_arg a ty = ASSERT( not (isUnliftedType ty) ) noLoc (mkBindStmt (nlVarPat a) (nlHsVarApps step_RDR [readPrec_RDR])) - read_field lbl a = read_lbl lbl ++- [read_punc "=",- noLoc (mkBindStmt (nlVarPat a) (nlHsVarApps reset_RDR [readPrec_RDR]))]-- -- When reading field labels we might encounter- -- a = 3- -- _a = 3- -- or (#) = 4- -- Note the parens!- read_lbl lbl | isSym lbl_str- = [read_punc "(", symbol_pat lbl_str, read_punc ")"]- | otherwise- = ident_h_pat lbl_str- where- lbl_str = unpackFS lbl+ -- When reading field labels we might encounter+ -- a = 3+ -- _a = 3+ -- or (#) = 4+ -- Note the parens!+ read_field lbl a =+ [noLoc+ (mkBindStmt+ (nlVarPat a)+ (nlHsApps+ read_field+ [ nlHsLit (mkHsString lbl_str)+ , nlHsVarApps reset_RDR [readPrec_RDR]+ ]+ )+ )+ ]+ where+ lbl_str = unpackFS lbl+ read_field+ | isSym lbl_str = readSymField_RDR+ | otherwise = readField_RDR {- ************************************************************************@@ -1114,17 +1125,14 @@ -- the most tightly-binding operator -} -gen_Show_binds :: (Name -> Fixity) -> SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)+gen_Show_binds :: (Name -> Fixity) -> SrcSpan -> TyCon+ -> (LHsBinds GhcPs, BagDerivStuff) gen_Show_binds get_fixity loc tycon- = (listToBag [shows_prec, show_list], emptyBag)+ = (unitBag shows_prec, emptyBag) where- ------------------------------------------------------------------------ show_list = mkHsVarBind loc showList_RDR- (nlHsApp (nlHsVar showList___RDR) (nlHsPar (nlHsApp (nlHsVar showsPrec_RDR) (nlHsIntLit 0))))- ----------------------------------------------------------------------- data_cons = tyConDataCons tycon- shows_prec = mk_FunBind loc showsPrec_RDR (map pats_etc data_cons)+ shows_prec = mkFunBindEC 2 loc showsPrec_RDR id (map pats_etc data_cons) comma_space = nlHsVar showCommaSpace_RDR pats_etc data_con@@ -1133,8 +1141,8 @@ ([nlWildPat, con_pat], mk_showString_app op_con_str) | otherwise = ([a_Pat, con_pat],- showParen_Expr (genOpApp a_Expr ge_RDR- (nlHsLit (HsInt NoSourceText con_prec_plus_one)))+ showParen_Expr (genOpApp a_Expr ge_RDR (nlHsLit+ (HsInt def (mkIntegralLit con_prec_plus_one)))) (nlHsPar (nested_compose_Expr show_thingies))) where data_con_RDR = getRdrName data_con@@ -1180,7 +1188,7 @@ | (lbl,arg) <- zipEqual "gen_Show_binds" labels show_args ] - show_arg :: RdrName -> Type -> LHsExpr RdrName+ show_arg :: RdrName -> Type -> LHsExpr GhcPs show_arg b arg_ty | isUnliftedType arg_ty -- See Note [Deriving and unboxed types] in TcDeriv@@ -1212,16 +1220,16 @@ isSym (c : _) = startsVarSym c || startsConSym c -- | showString :: String -> ShowS-mk_showString_app :: String -> LHsExpr RdrName+mk_showString_app :: String -> LHsExpr GhcPs mk_showString_app str = nlHsApp (nlHsVar showString_RDR) (nlHsLit (mkHsString str)) -- | showsPrec :: Show a => Int -> a -> ShowS-mk_showsPrec_app :: Integer -> LHsExpr RdrName -> LHsExpr RdrName+mk_showsPrec_app :: Integer -> LHsExpr GhcPs -> LHsExpr GhcPs mk_showsPrec_app p x- = nlHsApps showsPrec_RDR [nlHsLit (HsInt NoSourceText p), x]+ = nlHsApps showsPrec_RDR [nlHsLit (HsInt def (mkIntegralLit p)), x] -- | shows :: Show a => a -> ShowS-mk_shows_app :: LHsExpr RdrName -> LHsExpr RdrName+mk_shows_app :: LHsExpr GhcPs -> LHsExpr GhcPs mk_shows_app x = nlHsApp (nlHsVar shows_RDR) x getPrec :: Bool -> (Name -> Fixity) -> Name -> Integer@@ -1281,8 +1289,8 @@ gen_Data_binds :: SrcSpan -> TyCon -- For data families, this is the -- *representation* TyCon- -> TcM (LHsBinds RdrName, -- The method bindings- BagDerivStuff) -- Auxiliary bindings+ -> TcM (LHsBinds GhcPs, -- The method bindings+ BagDerivStuff) -- Auxiliary bindings gen_Data_binds loc rep_tc = do { dflags <- getDynFlags @@ -1300,7 +1308,7 @@ gen_data :: DynFlags -> RdrName -> [RdrName] -> SrcSpan -> TyCon- -> (LHsBinds RdrName, -- The method bindings+ -> (LHsBinds GhcPs, -- The method bindings BagDerivStuff) -- Auxiliary bindings gen_data dflags data_type_name constr_names loc rep_tc = (listToBag [gfoldl_bind, gunfold_bind, toCon_bind, dataTypeOf_bind]@@ -1345,11 +1353,11 @@ | otherwise = prefix_RDR ------------ gfoldl- gfoldl_bind = mk_HRFunBind 2 loc gfoldl_RDR (map gfoldl_eqn data_cons)+ gfoldl_bind = mkFunBindEC 3 loc gfoldl_RDR id (map gfoldl_eqn data_cons) gfoldl_eqn con- = ([nlVarPat k_RDR, nlVarPat z_RDR, nlConVarPat con_name as_needed],- foldl mk_k_app (nlHsVar z_RDR `nlHsApp` nlHsVar con_name) as_needed)+ = ([nlVarPat k_RDR, z_Pat, nlConVarPat con_name as_needed],+ foldl mk_k_app (z_Expr `nlHsApp` nlHsVar con_name) as_needed) where con_name :: RdrName con_name = getRdrName con@@ -1357,10 +1365,10 @@ mk_k_app e v = nlHsPar (nlHsOpApp e k_RDR (nlHsVar v)) ------------ gunfold- gunfold_bind = mk_HRFunBind 2 loc+ gunfold_bind = mk_easy_FunBind loc gunfold_RDR- [([k_Pat, z_Pat, if one_constr then nlWildPat else c_Pat],- gunfold_rhs)]+ [k_Pat, z_Pat, if one_constr then nlWildPat else c_Pat]+ gunfold_rhs gunfold_rhs | one_constr = mk_unfold_rhs (head data_cons) -- No need for case@@ -1369,7 +1377,7 @@ gunfold_alt dc = mkHsCaseAlt (mk_unfold_pat dc) (mk_unfold_rhs dc) mk_unfold_rhs dc = foldr nlHsApp- (nlHsVar z_RDR `nlHsApp` nlHsVar (getRdrName dc))+ (z_Expr `nlHsApp` nlHsVar (getRdrName dc)) (replicate (dataConSourceArity dc) (nlHsVar k_RDR)) mk_unfold_pat dc -- Last one is a wild-pat, to avoid@@ -1381,7 +1389,8 @@ tag = dataConTag dc ------------ toConstr- toCon_bind = mk_FunBind loc toConstr_RDR (zipWith to_con_eqn data_cons constr_names)+ toCon_bind = mkFunBindEC 1 loc toConstr_RDR id+ (zipWith to_con_eqn data_cons constr_names) to_con_eqn dc con_name = ([nlWildConPat dc], nlHsVar con_name) ------------ dataTypeOf@@ -1514,21 +1523,12 @@ makeG_d. -} -gen_Lift_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)-gen_Lift_binds loc tycon- | null data_cons = (unitBag (L loc $ mkFunBind (L loc lift_RDR)- [mkMatch (mkPrefixFunRhs (L loc lift_RDR))- [nlWildPat] errorMsg_Expr- (noLoc emptyLocalBinds)])- , emptyBag)- | otherwise = (unitBag lift_bind, emptyBag)+gen_Lift_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)+gen_Lift_binds loc tycon = (unitBag lift_bind, emptyBag) where- errorMsg_Expr = nlHsVar error_RDR `nlHsApp` nlHsLit- (mkHsString $ "Can't lift value of empty datatype " ++ tycon_str)-- lift_bind = mk_FunBind loc lift_RDR (map pats_etc data_cons)+ lift_bind = mkFunBindEC 1 loc lift_RDR (nlHsApp pure_Expr)+ (map pats_etc data_cons) data_cons = tyConDataCons tycon- tycon_str = occNameString . nameOccName . tyConName $ tycon pats_etc data_con = ([con_pat], lift_Expr)@@ -1565,7 +1565,7 @@ | otherwise = foldl mk_appE_app conE_Expr lifted_as (a1:a2:_) = lifted_as -mk_appE_app :: LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName+mk_appE_app :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs mk_appE_app a b = nlHsApps appE_RDR [a, b] {-@@ -1647,7 +1647,7 @@ -- newtype itself) -> [Type] -- instance head parameters (incl. newtype) -> Type -- the representation type- -> TcM (LHsBinds RdrName, BagDerivStuff)+ -> TcM (LHsBinds GhcPs, BagDerivStuff) -- See Note [Newtype-deriving instances] gen_Newtype_binds loc cls inst_tvs inst_tys rhs_ty = do let ats = classATs cls@@ -1656,9 +1656,7 @@ return ( listToBag $ map mk_bind (classMethods cls) , listToBag $ map DerivFamInst atf_insts ) where- coerce_RDR = getRdrName coerceId-- mk_bind :: Id -> LHsBind RdrName+ mk_bind :: Id -> LHsBind GhcPs mk_bind meth_id = mkRdrFunBind (L loc meth_RDR) [mkSimpleMatch (mkPrefixFunRhs (L loc meth_RDR))@@ -1668,7 +1666,8 @@ meth_RDR = getRdrName meth_id - rhs_expr = nlHsVar coerce_RDR `nlHsAppType` from_ty+ rhs_expr = nlHsVar (getRdrName coerceId)+ `nlHsAppType` from_ty `nlHsAppType` to_ty `nlHsApp` nlHsVar meth_RDR @@ -1680,7 +1679,7 @@ fam_tc rep_lhs_tys rep_rhs_ty -- Check (c) from Note [GND and associated type families] in TcDeriv checkValidTyFamEqn (Just (cls, cls_tvs, lhs_env)) fam_tc rep_tvs'- rep_cvs' rep_lhs_tys rep_rhs_ty loc+ rep_cvs' rep_lhs_tys rep_rhs_ty pp_lhs loc newFamInst SynFamilyInst axiom where cls_tvs = classTyVars cls@@ -1697,13 +1696,14 @@ (rep_tvs, rep_cvs) = partition isTyVar rep_tcvs rep_tvs' = toposortTyVars rep_tvs rep_cvs' = toposortTyVars rep_cvs+ pp_lhs = ppr (mkTyConApp fam_tc rep_lhs_tys) -nlHsAppType :: LHsExpr RdrName -> Type -> LHsExpr RdrName+nlHsAppType :: LHsExpr GhcPs -> Type -> LHsExpr GhcPs nlHsAppType e s = noLoc (e `HsAppType` hs_ty) where hs_ty = mkHsWildCardBndrs $ nlHsParTy (typeToLHsType s) -nlExprWithTySig :: LHsExpr RdrName -> Type -> LHsExpr RdrName+nlExprWithTySig :: LHsExpr GhcPs -> Type -> LHsExpr GhcPs nlExprWithTySig e s = noLoc (e `ExprWithTySig` hs_ty) where hs_ty = mkLHsSigWcType (typeToLHsType s)@@ -1751,9 +1751,9 @@ -} genAuxBindSpec :: DynFlags -> SrcSpan -> AuxBindSpec- -> (LHsBind RdrName, LSig RdrName)+ -> (LHsBind GhcPs, LSig GhcPs) genAuxBindSpec dflags loc (DerivCon2Tag tycon)- = (mk_FunBind loc rdr_name eqns,+ = (mkFunBindSE 0 loc rdr_name eqns, L loc (TypeSig [L loc rdr_name] sig_ty)) where rdr_name = con2tag_RDR dflags tycon@@ -1771,13 +1771,13 @@ get_tag_eqn = ([nlVarPat a_RDR], nlHsApp (nlHsVar getTag_RDR) a_Expr) - mk_eqn :: DataCon -> ([LPat RdrName], LHsExpr RdrName)+ mk_eqn :: DataCon -> ([LPat GhcPs], LHsExpr GhcPs) mk_eqn con = ([nlWildConPat con], nlHsLit (HsIntPrim NoSourceText (toInteger ((dataConTag con) - fIRST_TAG)))) genAuxBindSpec dflags loc (DerivTag2Con tycon)- = (mk_FunBind loc rdr_name+ = (mkFunBindSE 0 loc rdr_name [([nlConVarPat intDataCon_RDR [a_RDR]], nlHsApp (nlHsVar tagToEnum_RDR) a_Expr)], L loc (TypeSig [L loc rdr_name] sig_ty))@@ -1801,7 +1801,7 @@ type SeparateBagsDerivStuff = -- AuxBinds and SYB bindings- ( Bag (LHsBind RdrName, LSig RdrName)+ ( Bag (LHsBind GhcPs, LSig GhcPs) -- Extra family instances (used by Generic and DeriveAnyClass) , Bag (FamInst) ) @@ -1841,49 +1841,94 @@ ************************************************************************ -} -mk_FunBind :: SrcSpan -> RdrName- -> [([LPat RdrName], LHsExpr RdrName)]- -> LHsBind RdrName-mk_FunBind = mk_HRFunBind 0 -- by using mk_FunBind and not mk_HRFunBind,- -- the caller says that the Void case needs no- -- patterns---- | This variant of 'mk_FunBind' puts an 'Arity' number of wildcards before--- the "=" in the empty-data-decl case. This is necessary if the function--- has a higher-rank type, like foldl. (See deriving/should_compile/T4302)-mk_HRFunBind :: Arity -> SrcSpan -> RdrName- -> [([LPat RdrName], LHsExpr RdrName)]- -> LHsBind RdrName-mk_HRFunBind arity loc fun pats_and_exprs- = mkHRRdrFunBind arity (L loc fun) matches+-- | Make a function binding. If no equations are given, produce a function+-- with the given arity that produces a stock error.+mkFunBindSE :: Arity -> SrcSpan -> RdrName+ -> [([LPat GhcPs], LHsExpr GhcPs)]+ -> LHsBind GhcPs+mkFunBindSE arity loc fun pats_and_exprs+ = mkRdrFunBindSE arity (L loc fun) matches where- matches = [mkMatch (mkPrefixFunRhs (L loc fun)) p e+ matches = [mkMatch (mkPrefixFunRhs (L loc fun))+ (map parenthesizeCompoundPat p) e (noLoc emptyLocalBinds) | (p,e) <-pats_and_exprs] -mkRdrFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> LHsBind RdrName-mkRdrFunBind = mkHRRdrFunBind 0+mkRdrFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)]+ -> LHsBind GhcPs+mkRdrFunBind fun@(L loc _fun_rdr) matches+ = L loc (mkFunBind fun matches) -mkHRRdrFunBind :: Arity -> Located RdrName -> [LMatch RdrName (LHsExpr RdrName)] -> LHsBind RdrName-mkHRRdrFunBind arity fun@(L loc fun_rdr) matches = L loc (mkFunBind fun matches')+-- | Make a function binding. If no equations are given, produce a function+-- with the given arity that uses an empty case expression for the last+-- argument that is passes to the given function to produce the right-hand+-- side.+mkFunBindEC :: Arity -> SrcSpan -> RdrName+ -> (LHsExpr GhcPs -> LHsExpr GhcPs)+ -> [([LPat GhcPs], LHsExpr GhcPs)]+ -> LHsBind GhcPs+mkFunBindEC arity loc fun catch_all pats_and_exprs+ = mkRdrFunBindEC arity catch_all (L loc fun) matches+ where+ matches = [ mkMatch (mkPrefixFunRhs (L loc fun))+ (map parenthesizeCompoundPat p) e+ (noLoc emptyLocalBinds)+ | (p,e) <- pats_and_exprs ]++-- | Produces a function binding. When no equations are given, it generates+-- a binding of the given arity and an empty case expression+-- for the last argument that it passes to the given function to produce+-- the right-hand side.+mkRdrFunBindEC :: Arity+ -> (LHsExpr GhcPs -> LHsExpr GhcPs)+ -> Located RdrName+ -> [LMatch GhcPs (LHsExpr GhcPs)]+ -> LHsBind GhcPs+mkRdrFunBindEC arity catch_all+ fun@(L loc _fun_rdr) matches = L loc (mkFunBind fun matches') where -- Catch-all eqn looks like- -- fmap = error "Void fmap"+ -- fmap _ z = case z of {}+ -- or+ -- traverse _ z = pure (case z of)+ -- or+ -- foldMap _ z = mempty -- It's needed if there no data cons at all, -- which can happen with -XEmptyDataDecls -- See Trac #4302 matches' = if null matches then [mkMatch (mkPrefixFunRhs fun)+ (replicate (arity - 1) nlWildPat ++ [z_Pat])+ (catch_all $ nlHsCase z_Expr [])+ (noLoc emptyLocalBinds)]+ else matches++-- | Produces a function binding. When there are no equations, it generates+-- a binding with the given arity that produces an error based on the name of+-- the type of the last argument.+mkRdrFunBindSE :: Arity -> Located RdrName ->+ [LMatch GhcPs (LHsExpr GhcPs)] -> LHsBind GhcPs+mkRdrFunBindSE arity+ fun@(L loc fun_rdr) matches = L loc (mkFunBind fun matches')+ where+ -- Catch-all eqn looks like+ -- compare _ _ = error "Void compare"+ -- It's needed if there no data cons at all,+ -- which can happen with -XEmptyDataDecls+ -- See Trac #4302+ matches' = if null matches+ then [mkMatch (mkPrefixFunRhs fun) (replicate arity nlWildPat) (error_Expr str) (noLoc emptyLocalBinds)] else matches str = "Void " ++ occNameString (rdrNameOcc fun_rdr) + box :: String -- The class involved -> TyCon -- The tycon involved- -> LHsExpr RdrName -- The argument+ -> LHsExpr GhcPs -- The argument -> Type -- The argument type- -> LHsExpr RdrName -- Boxed version of the arg+ -> LHsExpr GhcPs -- Boxed version of the arg -- See Note [Deriving and unboxed types] in TcDeriv box cls_str tycon arg arg_ty = nlHsApp (nlHsVar box_con) arg where@@ -1900,8 +1945,8 @@ primLitOps :: String -- The class involved -> TyCon -- The tycon involved -> Type -- The type- -> ( LHsExpr RdrName -> LHsExpr RdrName -- Constructs a Q Exp value- , LHsExpr RdrName -> LHsExpr RdrName -- Constructs a boxed value+ -> ( LHsExpr GhcPs -> LHsExpr GhcPs -- Constructs a Q Exp value+ , LHsExpr GhcPs -> LHsExpr GhcPs -- Constructs a boxed value ) primLitOps str tycon ty = ( assoc_ty_id str tycon litConTbl ty , \v -> nlHsVar boxRDR `nlHsApp` v@@ -1939,7 +1984,7 @@ ,(doublePrimTy, "##") ] -litConTbl :: [(Type, LHsExpr RdrName -> LHsExpr RdrName)]+litConTbl :: [(Type, LHsExpr GhcPs -> LHsExpr GhcPs)] litConTbl = [(charPrimTy , nlHsApp (nlHsVar charPrimL_RDR)) ,(intPrimTy , nlHsApp (nlHsVar intPrimL_RDR)@@ -1974,12 +2019,12 @@ ----------------------------------------------------------------------- -and_Expr :: LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName+and_Expr :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs and_Expr a b = genOpApp a and_RDR b ----------------------------------------------------------------------- -eq_Expr :: TyCon -> Type -> LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName+eq_Expr :: TyCon -> Type -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs eq_Expr tycon ty a b | not (isUnliftedType ty) = genOpApp a eq_RDR b | otherwise = genPrimOpApp a prim_eq b@@ -1987,7 +2032,7 @@ (_, _, prim_eq, _, _) = primOrdOps "Eq" tycon ty untag_Expr :: DynFlags -> TyCon -> [( RdrName, RdrName)]- -> LHsExpr RdrName -> LHsExpr RdrName+ -> LHsExpr GhcPs -> LHsExpr GhcPs untag_Expr _ _ [] expr = expr untag_Expr dflags tycon ((untag_this, put_tag_here) : more) expr = nlHsCase (nlHsPar (nlHsVarApps (con2tag_RDR dflags tycon)@@ -1995,22 +2040,22 @@ [mkHsCaseAlt (nlVarPat put_tag_here) (untag_Expr dflags tycon more expr)] enum_from_to_Expr- :: LHsExpr RdrName -> LHsExpr RdrName- -> LHsExpr RdrName+ :: LHsExpr GhcPs -> LHsExpr GhcPs+ -> LHsExpr GhcPs enum_from_then_to_Expr- :: LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName- -> LHsExpr RdrName+ :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs+ -> LHsExpr GhcPs enum_from_to_Expr f t2 = nlHsApp (nlHsApp (nlHsVar enumFromTo_RDR) f) t2 enum_from_then_to_Expr f t t2 = nlHsApp (nlHsApp (nlHsApp (nlHsVar enumFromThenTo_RDR) f) t) t2 showParen_Expr- :: LHsExpr RdrName -> LHsExpr RdrName- -> LHsExpr RdrName+ :: LHsExpr GhcPs -> LHsExpr GhcPs+ -> LHsExpr GhcPs showParen_Expr e1 e2 = nlHsApp (nlHsApp (nlHsVar showParen_RDR) e1) e2 -nested_compose_Expr :: [LHsExpr RdrName] -> LHsExpr RdrName+nested_compose_Expr :: [LHsExpr GhcPs] -> LHsExpr GhcPs nested_compose_Expr [] = panic "nested_compose_expr" -- Arg is always non-empty nested_compose_Expr [e] = parenify e@@ -2019,18 +2064,18 @@ -- impossible_Expr is used in case RHSs that should never happen. -- We generate these to keep the desugarer from complaining that they *might* happen!-error_Expr :: String -> LHsExpr RdrName+error_Expr :: String -> LHsExpr GhcPs error_Expr string = nlHsApp (nlHsVar error_RDR) (nlHsLit (mkHsString string)) -- illegal_Expr is used when signalling error conditions in the RHS of a derived -- method. It is currently only used by Enum.{succ,pred}-illegal_Expr :: String -> String -> String -> LHsExpr RdrName+illegal_Expr :: String -> String -> String -> LHsExpr GhcPs illegal_Expr meth tp msg = nlHsApp (nlHsVar error_RDR) (nlHsLit (mkHsString (meth ++ '{':tp ++ "}: " ++ msg))) -- illegal_toEnum_tag is an extended version of illegal_Expr, which also allows you -- to include the value of a_RDR in the error string.-illegal_toEnum_tag :: String -> RdrName -> LHsExpr RdrName+illegal_toEnum_tag :: String -> RdrName -> LHsExpr GhcPs illegal_toEnum_tag tp maxtag = nlHsApp (nlHsVar error_RDR) (nlHsApp (nlHsApp (nlHsVar append_RDR)@@ -2048,16 +2093,16 @@ (nlHsVar maxtag)) (nlHsLit (mkHsString ")")))))) -parenify :: LHsExpr RdrName -> LHsExpr RdrName+parenify :: LHsExpr GhcPs -> LHsExpr GhcPs parenify e@(L _ (HsVar _)) = e parenify e = mkHsPar e -- genOpApp wraps brackets round the operator application, so that the -- renamer won't subsequently try to re-associate it.-genOpApp :: LHsExpr RdrName -> RdrName -> LHsExpr RdrName -> LHsExpr RdrName+genOpApp :: LHsExpr GhcPs -> RdrName -> LHsExpr GhcPs -> LHsExpr GhcPs genOpApp e1 op e2 = nlHsPar (nlHsOpApp e1 op e2) -genPrimOpApp :: LHsExpr RdrName -> RdrName -> LHsExpr RdrName -> LHsExpr RdrName+genPrimOpApp :: LHsExpr GhcPs -> RdrName -> LHsExpr GhcPs -> LHsExpr GhcPs genPrimOpApp e1 op e2 = nlHsPar (nlHsApp (nlHsVar tagToEnum_RDR) (nlHsOpApp e1 op e2)) a_RDR, b_RDR, c_RDR, d_RDR, f_RDR, k_RDR, z_RDR, ah_RDR, bh_RDR, ch_RDR, dh_RDR@@ -2079,18 +2124,20 @@ bs_RDRs = [ mkVarUnqual (mkFastString ("b"++show i)) | i <- [(1::Int) .. ] ] cs_RDRs = [ mkVarUnqual (mkFastString ("c"++show i)) | i <- [(1::Int) .. ] ] -a_Expr, b_Expr, c_Expr, ltTag_Expr, eqTag_Expr, gtTag_Expr, false_Expr,- true_Expr :: LHsExpr RdrName+a_Expr, b_Expr, c_Expr, z_Expr, ltTag_Expr, eqTag_Expr, gtTag_Expr, false_Expr,+ true_Expr, pure_Expr :: LHsExpr GhcPs a_Expr = nlHsVar a_RDR b_Expr = nlHsVar b_RDR c_Expr = nlHsVar c_RDR+z_Expr = nlHsVar z_RDR ltTag_Expr = nlHsVar ltTag_RDR eqTag_Expr = nlHsVar eqTag_RDR gtTag_Expr = nlHsVar gtTag_RDR false_Expr = nlHsVar false_RDR true_Expr = nlHsVar true_RDR+pure_Expr = nlHsVar pure_RDR -a_Pat, b_Pat, c_Pat, d_Pat, k_Pat, z_Pat :: LPat RdrName+a_Pat, b_Pat, c_Pat, d_Pat, k_Pat, z_Pat :: LPat GhcPs a_Pat = nlVarPat a_RDR b_Pat = nlVarPat b_RDR c_Pat = nlVarPat c_RDR
typecheck/TcGenFunctor.hs view
@@ -7,6 +7,7 @@ -} {-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-} module TcGenFunctor ( FFoldType(..), functorLikeTraverse,@@ -15,6 +16,8 @@ gen_Functor_binds, gen_Foldable_binds, gen_Traversable_binds ) where +import GhcPrelude+ import Bag import DataCon import FastString@@ -32,6 +35,8 @@ import Util import Var import VarSet+import MkId (coerceId)+import TysWiredIn (true_RDR, false_RDR) import Data.Maybe (catMaybes, isJust) @@ -122,13 +127,28 @@ It is better to produce too many lambdas than to eta expand, see ticket #7436. -} -gen_Functor_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)+gen_Functor_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)+-- When the argument is phantom, we can use fmap _ = coerce+-- See Note [Phantom types with Functor, Foldable, and Traversable] gen_Functor_binds loc tycon+ | Phantom <- last (tyConRoles tycon)+ = (unitBag fmap_bind, emptyBag)+ where+ fmap_name = L loc fmap_RDR+ fmap_bind = mkRdrFunBind fmap_name fmap_eqns+ fmap_eqns = [mkSimpleMatch fmap_match_ctxt+ [nlWildPat]+ coerce_Expr]+ fmap_match_ctxt = mkPrefixFunRhs fmap_name++gen_Functor_binds loc tycon = (listToBag [fmap_bind, replace_bind], emptyBag) where data_cons = tyConDataCons tycon fmap_name = L loc fmap_RDR- fmap_bind = mkRdrFunBind fmap_name fmap_eqns++ -- See Note [EmptyDataDecls with Functor, Foldable, and Traversable]+ fmap_bind = mkRdrFunBindEC 2 id fmap_name fmap_eqns fmap_match_ctxt = mkPrefixFunRhs fmap_name fmap_eqn con = flip evalState bs_RDRs $@@ -136,13 +156,9 @@ where parts = sequence $ foldDataConArgs ft_fmap con - fmap_eqns- | null data_cons = [mkSimpleMatch fmap_match_ctxt- [nlWildPat, nlWildPat]- (error_Expr "Void fmap")]- | otherwise = map fmap_eqn data_cons+ fmap_eqns = map fmap_eqn data_cons - ft_fmap :: FFoldType (State [RdrName] (LHsExpr RdrName))+ ft_fmap :: FFoldType (State [RdrName] (LHsExpr GhcPs)) ft_fmap = FT { ft_triv = mkSimpleLam $ \x -> return x -- fmap f = \x -> x , ft_var = return f_Expr@@ -160,12 +176,14 @@ , ft_ty_app = \_ g -> nlHsApp fmap_Expr <$> g -- fmap f = fmap g , ft_forall = \_ g -> g- , ft_bad_app = panic "in other argument"- , ft_co_var = panic "contravariant" }+ , ft_bad_app = panic "in other argument in ft_fmap"+ , ft_co_var = panic "contravariant in ft_fmap" } - -- See Note [deriving <$]+ -- See Note [Deriving <$] replace_name = L loc replace_RDR- replace_bind = mkRdrFunBind replace_name replace_eqns++ -- See Note [EmptyDataDecls with Functor, Foldable, and Traversable]+ replace_bind = mkRdrFunBindEC 2 id replace_name replace_eqns replace_match_ctxt = mkPrefixFunRhs replace_name replace_eqn con = flip evalState bs_RDRs $@@ -173,11 +191,7 @@ where parts = traverse (fmap replace) $ foldDataConArgs ft_replace con - replace_eqns- | null data_cons = [mkSimpleMatch replace_match_ctxt- [nlWildPat, nlWildPat]- (error_Expr "Void <$")]- | otherwise = map replace_eqn data_cons+ replace_eqns = map replace_eqn data_cons ft_replace :: FFoldType (State [RdrName] Replacer) ft_replace = FT { ft_triv = fmap Nested $ mkSimpleLam $ \x -> return x@@ -204,21 +218,21 @@ nlHsApp replace_Expr z_Expr -- (p <$) = fmap (p <$) , ft_forall = \_ g -> g- , ft_bad_app = panic "in other argument"- , ft_co_var = panic "contravariant" }+ , ft_bad_app = panic "in other argument in ft_replace"+ , ft_co_var = panic "contravariant in ft_replace" } -- Con a1 a2 ... -> Con (f1 a1) (f2 a2) ... match_for_con :: HsMatchContext RdrName- -> [LPat RdrName] -> DataCon -> [LHsExpr RdrName]- -> State [RdrName] (LMatch RdrName (LHsExpr RdrName))+ -> [LPat GhcPs] -> DataCon -> [LHsExpr GhcPs]+ -> State [RdrName] (LMatch GhcPs (LHsExpr GhcPs)) match_for_con ctxt = mkSimpleConMatch ctxt $ \con_name xs -> return $ nlHsApps con_name xs -- Con x1 x2 .. --- See Note [deriving <$]-data Replacer = Immediate {replace :: LHsExpr RdrName}- | Nested {replace :: LHsExpr RdrName}+-- See Note [Deriving <$]+data Replacer = Immediate {replace :: LHsExpr GhcPs}+ | Nested {replace :: LHsExpr GhcPs} -{- Note [deriving <$]+{- Note [Deriving <$] ~~~~~~~~~~~~~~~~~~ We derive the definition of <$. Allowing this to take the default definition@@ -393,8 +407,8 @@ , ft_fun = (++) , ft_tup = \_ xs -> concat xs , ft_ty_app = (:)- , ft_bad_app = panic "in other argument"- , ft_co_var = panic "contravariant"+ , ft_bad_app = panic "in other argument in deepSubtypesContaining"+ , ft_co_var = panic "contravariant in deepSubtypesContaining" , ft_forall = \v xs -> filterOut ((v `elemVarSet`) . tyCoVarsOfType) xs }) @@ -417,8 +431,8 @@ -- The kind checks have ensured the last type parameter is of kind *. -- Make a HsLam using a fresh variable from a State monad-mkSimpleLam :: (LHsExpr RdrName -> State [RdrName] (LHsExpr RdrName))- -> State [RdrName] (LHsExpr RdrName)+mkSimpleLam :: (LHsExpr GhcPs -> State [RdrName] (LHsExpr GhcPs))+ -> State [RdrName] (LHsExpr GhcPs) -- (mkSimpleLam fn) returns (\x. fn(x)) mkSimpleLam lam = do (n:names) <- get@@ -426,9 +440,9 @@ body <- lam (nlHsVar n) return (mkHsLam [nlVarPat n] body) -mkSimpleLam2 :: (LHsExpr RdrName -> LHsExpr RdrName- -> State [RdrName] (LHsExpr RdrName))- -> State [RdrName] (LHsExpr RdrName)+mkSimpleLam2 :: (LHsExpr GhcPs -> LHsExpr GhcPs+ -> State [RdrName] (LHsExpr GhcPs))+ -> State [RdrName] (LHsExpr GhcPs) mkSimpleLam2 lam = do (n1:n2:names) <- get put names@@ -443,11 +457,11 @@ -- and its arguments, applying an expression (from @insides@) to each of the -- respective arguments of @con@. mkSimpleConMatch :: Monad m => HsMatchContext RdrName- -> (RdrName -> [LHsExpr RdrName] -> m (LHsExpr RdrName))- -> [LPat RdrName]+ -> (RdrName -> [LHsExpr GhcPs] -> m (LHsExpr GhcPs))+ -> [LPat GhcPs] -> DataCon- -> [LHsExpr RdrName]- -> m (LMatch RdrName (LHsExpr RdrName))+ -> [LHsExpr GhcPs]+ -> m (LMatch GhcPs (LHsExpr GhcPs)) mkSimpleConMatch ctxt fold extra_pats con insides = do let con_name = getRdrName con let vars_needed = takeList insides as_RDRs@@ -455,7 +469,8 @@ let pat = if null vars_needed then bare_pat else nlParPat bare_pat- rhs <- fold con_name (zipWith nlHsApp insides (map nlHsVar vars_needed))+ rhs <- fold con_name+ (zipWith (\i v -> i `nlHsApp` nlHsVar v) insides vars_needed) return $ mkMatch ctxt (extra_pats ++ [pat]) rhs (noLoc emptyLocalBinds) @@ -478,12 +493,12 @@ -- See Note [Generated code for DeriveFoldable and DeriveTraversable] mkSimpleConMatch2 :: Monad m => HsMatchContext RdrName- -> (LHsExpr RdrName -> [LHsExpr RdrName]- -> m (LHsExpr RdrName))- -> [LPat RdrName]+ -> (LHsExpr GhcPs -> [LHsExpr GhcPs]+ -> m (LHsExpr GhcPs))+ -> [LPat GhcPs] -> DataCon- -> [Maybe (LHsExpr RdrName)]- -> m (LMatch RdrName (LHsExpr RdrName))+ -> [Maybe (LHsExpr GhcPs)]+ -> m (LMatch GhcPs (LHsExpr GhcPs)) mkSimpleConMatch2 ctxt fold extra_pats con insides = do let con_name = getRdrName con vars_needed = takeList insides as_RDRs@@ -491,21 +506,19 @@ -- Make sure to zip BEFORE invoking catMaybes. We want the variable -- indicies in each expression to match up with the argument indices -- in con_expr (defined below).- exps = catMaybes $ zipWith (\i v -> (`nlHsApp` v) <$> i)- insides (map nlHsVar vars_needed)+ exps = catMaybes $ zipWith (\i v -> (`nlHsApp` nlHsVar v) <$> i)+ insides vars_needed -- An element of argTysTyVarInfo is True if the constructor argument -- with the same index has a type which mentions the last type -- variable. argTysTyVarInfo = map isJust insides- (asWithTyVar, asWithoutTyVar) = partitionByList argTysTyVarInfo as_RDRs+ (asWithTyVar, asWithoutTyVar) = partitionByList argTysTyVarInfo as_Vars con_expr- | null asWithTyVar = nlHsApps con_name $ map nlHsVar asWithoutTyVar+ | null asWithTyVar = nlHsApps con_name asWithoutTyVar | otherwise = let bs = filterByList argTysTyVarInfo bs_RDRs- vars = filterByLists argTysTyVarInfo- (map nlHsVar bs_RDRs)- (map nlHsVar as_RDRs)+ vars = filterByLists argTysTyVarInfo bs_Vars as_Vars in mkHsLam (map nlVarPat bs) (nlHsApps con_name vars) rhs <- fold con_expr exps@@ -513,9 +526,9 @@ (noLoc emptyLocalBinds) -- "case x of (a1,a2,a3) -> fold [x1 a1, x2 a2, x3 a3]"-mkSimpleTupleCase :: Monad m => ([LPat RdrName] -> DataCon -> [a]- -> m (LMatch RdrName (LHsExpr RdrName)))- -> TyCon -> [a] -> LHsExpr RdrName -> m (LHsExpr RdrName)+mkSimpleTupleCase :: Monad m => ([LPat GhcPs] -> DataCon -> [a]+ -> m (LMatch GhcPs (LHsExpr GhcPs)))+ -> TyCon -> [a] -> LHsExpr GhcPs -> m (LHsExpr GhcPs) mkSimpleTupleCase match_for_con tc insides x = do { let data_con = tyConSingleDataCon tc ; match <- match_for_con [] data_con insides@@ -586,12 +599,70 @@ See Note [DeriveFoldable with ExistentialQuantification]. +Note [Deriving null]+~~~~~~~~~~~~~~~~~~~~++In some cases, deriving the definition of 'null' can produce much better+results than the default definition. For example, with++ data SnocList a = Nil | Snoc (SnocList a) a++the default definition of 'null' would walk the entire spine of a+nonempty snoc-list before concluding that it is not null. But looking at+the Snoc constructor, we can immediately see that it contains an 'a', and+so 'null' can return False immediately if it matches on Snoc. When we+derive 'null', we keep track of things that cannot be null. The interesting+case is type application. Given++ data Wrap a = Wrap (Foo (Bar a))++we use++ null (Wrap fba) = all null fba++but if we see++ data Wrap a = Wrap (Foo a)++we can just use++ null (Wrap fa) = null fa++Indeed, we allow this to happen even for tuples:++ data Wrap a = Wrap (Foo (a, Int))++produces++ null (Wrap fa) = null fa++As explained in Note [Deriving <$], giving tuples special performance treatment+could surprise users if they switch to other types, but Ryan Scott seems to+think it's okay to do it for now. -} -gen_Foldable_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)+gen_Foldable_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)+-- When the parameter is phantom, we can use foldMap _ _ = mempty+-- See Note [Phantom types with Functor, Foldable, and Traversable] gen_Foldable_binds loc tycon- = (listToBag [foldr_bind, foldMap_bind], emptyBag)+ | Phantom <- last (tyConRoles tycon)+ = (unitBag foldMap_bind, emptyBag) where+ foldMap_name = L loc foldMap_RDR+ foldMap_bind = mkRdrFunBind foldMap_name foldMap_eqns+ foldMap_eqns = [mkSimpleMatch foldMap_match_ctxt+ [nlWildPat, nlWildPat]+ mempty_Expr]+ foldMap_match_ctxt = mkPrefixFunRhs foldMap_name++gen_Foldable_binds loc tycon+ | null data_cons -- There's no real point producing anything but+ -- foldMap for a type with no constructors.+ = (unitBag foldMap_bind, emptyBag)++ | otherwise+ = (listToBag [foldr_bind, foldMap_bind, null_bind], emptyBag)+ where data_cons = tyConDataCons tycon foldr_bind = mkRdrFunBind (L loc foldable_foldr_RDR) eqns@@ -601,16 +672,46 @@ where parts = sequence $ foldDataConArgs ft_foldr con - foldMap_bind = mkRdrFunBind (L loc foldMap_RDR) (map foldMap_eqn data_cons)+ foldMap_name = L loc foldMap_RDR++ -- See Note [EmptyDataDecls with Functor, Foldable, and Traversable]+ foldMap_bind = mkRdrFunBindEC 2 (const mempty_Expr)+ foldMap_name foldMap_eqns++ foldMap_eqns = map foldMap_eqn data_cons+ foldMap_eqn con = evalState (match_foldMap [f_Pat] con =<< parts) bs_RDRs where parts = sequence $ foldDataConArgs ft_foldMap con + -- Given a list of NullM results, produce Nothing if any of+ -- them is NotNull, and otherwise produce a list of Maybes+ -- with Justs representing unknowns and Nothings representing+ -- things that are definitely null.+ convert :: [NullM a] -> Maybe [Maybe a]+ convert = traverse go where+ go IsNull = Just Nothing+ go NotNull = Nothing+ go (NullM a) = Just (Just a)++ null_name = L loc null_RDR+ null_match_ctxt = mkPrefixFunRhs null_name+ null_bind = mkRdrFunBind null_name null_eqns+ null_eqns = map null_eqn data_cons+ null_eqn con+ = flip evalState bs_RDRs $ do+ parts <- sequence $ foldDataConArgs ft_null con+ case convert parts of+ Nothing -> return $+ mkMatch null_match_ctxt [nlParPat (nlWildConPat con)]+ false_Expr (noLoc emptyLocalBinds)+ Just cp -> match_null [] con cp+ -- Yields 'Just' an expression if we're folding over a type that mentions -- the last type parameter of the datatype. Otherwise, yields 'Nothing'. -- See Note [FFoldType and functorLikeTraverse]- ft_foldr :: FFoldType (State [RdrName] (Maybe (LHsExpr RdrName)))+ ft_foldr :: FFoldType (State [RdrName] (Maybe (LHsExpr GhcPs))) ft_foldr = FT { ft_triv = return Nothing -- foldr f = \x z -> z@@ -628,23 +729,23 @@ nlHsApps foldable_foldr_RDR [gg',z,x]) gg -- foldr f = (\x z -> foldr g z x) , ft_forall = \_ g -> g- , ft_co_var = panic "contravariant"- , ft_fun = panic "function"- , ft_bad_app = panic "in other argument" }+ , ft_co_var = panic "contravariant in ft_foldr"+ , ft_fun = panic "function in ft_foldr"+ , ft_bad_app = panic "in other argument in ft_foldr" } - match_foldr :: LHsExpr RdrName- -> [LPat RdrName]+ match_foldr :: LHsExpr GhcPs+ -> [LPat GhcPs] -> DataCon- -> [Maybe (LHsExpr RdrName)]- -> State [RdrName] (LMatch RdrName (LHsExpr RdrName))+ -> [Maybe (LHsExpr GhcPs)]+ -> State [RdrName] (LMatch GhcPs (LHsExpr GhcPs)) match_foldr z = mkSimpleConMatch2 LambdaExpr $ \_ xs -> return (mkFoldr xs) where -- g1 v1 (g2 v2 (.. z))- mkFoldr :: [LHsExpr RdrName] -> LHsExpr RdrName+ mkFoldr :: [LHsExpr GhcPs] -> LHsExpr GhcPs mkFoldr = foldr nlHsApp z -- See Note [FFoldType and functorLikeTraverse]- ft_foldMap :: FFoldType (State [RdrName] (Maybe (LHsExpr RdrName)))+ ft_foldMap :: FFoldType (State [RdrName] (Maybe (LHsExpr GhcPs))) ft_foldMap = FT { ft_triv = return Nothing -- foldMap f = \x -> mempty@@ -658,21 +759,74 @@ , ft_ty_app = \_ g -> fmap (nlHsApp foldMap_Expr) <$> g -- foldMap f = foldMap g , ft_forall = \_ g -> g- , ft_co_var = panic "contravariant"- , ft_fun = panic "function"- , ft_bad_app = panic "in other argument" }+ , ft_co_var = panic "contravariant in ft_foldMap"+ , ft_fun = panic "function in ft_foldMap"+ , ft_bad_app = panic "in other argument in ft_foldMap" } - match_foldMap :: [LPat RdrName]+ match_foldMap :: [LPat GhcPs] -> DataCon- -> [Maybe (LHsExpr RdrName)]- -> State [RdrName] (LMatch RdrName (LHsExpr RdrName))+ -> [Maybe (LHsExpr GhcPs)]+ -> State [RdrName] (LMatch GhcPs (LHsExpr GhcPs)) match_foldMap = mkSimpleConMatch2 CaseAlt $ \_ xs -> return (mkFoldMap xs) where -- mappend v1 (mappend v2 ..)- mkFoldMap :: [LHsExpr RdrName] -> LHsExpr RdrName+ mkFoldMap :: [LHsExpr GhcPs] -> LHsExpr GhcPs mkFoldMap [] = mempty_Expr mkFoldMap xs = foldr1 (\x y -> nlHsApps mappend_RDR [x,y]) xs + -- See Note [FFoldType and functorLikeTraverse]+ -- Yields NullM an expression if we're folding over an expression+ -- that may or may not be null. Yields IsNull if it's certainly+ -- null, and yields NotNull if it's certainly not null.+ -- See Note [Deriving null]+ ft_null :: FFoldType (State [RdrName] (NullM (LHsExpr GhcPs)))+ ft_null+ = FT { ft_triv = return IsNull+ -- null = \_ -> True+ , ft_var = return NotNull+ -- null = \_ -> False+ , ft_tup = \t g -> do+ gg <- sequence g+ case convert gg of+ Nothing -> pure NotNull+ Just ggg ->+ NullM <$> (mkSimpleLam $ mkSimpleTupleCase match_null t ggg)+ -- null = \x -> case x of (..,)+ , ft_ty_app = \_ g -> flip fmap g $ \nestedResult ->+ case nestedResult of+ -- If e definitely contains the parameter,+ -- then we can test if (G e) contains it by+ -- simply checking if (G e) is null+ NotNull -> NullM null_Expr+ -- This case is unreachable--it will actually be+ -- caught by ft_triv+ IsNull -> IsNull+ -- The general case uses (all null),+ -- (all (all null)), etc.+ NullM nestedTest -> NullM $+ nlHsApp all_Expr nestedTest+ -- null fa = null fa, or null fa = all null fa, or null fa = True+ , ft_forall = \_ g -> g+ , ft_co_var = panic "contravariant in ft_null"+ , ft_fun = panic "function in ft_null"+ , ft_bad_app = panic "in other argument in ft_null" }++ match_null :: [LPat GhcPs]+ -> DataCon+ -> [Maybe (LHsExpr GhcPs)]+ -> State [RdrName] (LMatch GhcPs (LHsExpr GhcPs))+ match_null = mkSimpleConMatch2 CaseAlt $ \_ xs -> return (mkNull xs)+ where+ -- v1 && v2 && ..+ mkNull :: [LHsExpr GhcPs] -> LHsExpr GhcPs+ mkNull [] = true_Expr+ mkNull xs = foldr1 (\x y -> nlHsApps and_RDR [x,y]) xs++data NullM a =+ IsNull -- Definitely null+ | NotNull -- Definitely not null+ | NullM a -- Unknown+ {- ************************************************************************ * *@@ -713,14 +867,32 @@ See Note [Generated code for DeriveFoldable and DeriveTraversable]. -} -gen_Traversable_binds :: SrcSpan -> TyCon -> (LHsBinds RdrName, BagDerivStuff)+gen_Traversable_binds :: SrcSpan -> TyCon -> (LHsBinds GhcPs, BagDerivStuff)+-- When the argument is phantom, we can use traverse = pure . coerce+-- See Note [Phantom types with Functor, Foldable, and Traversable] gen_Traversable_binds loc tycon+ | Phantom <- last (tyConRoles tycon) = (unitBag traverse_bind, emptyBag) where+ traverse_name = L loc traverse_RDR+ traverse_bind = mkRdrFunBind traverse_name traverse_eqns+ traverse_eqns =+ [mkSimpleMatch traverse_match_ctxt+ [nlWildPat, z_Pat]+ (nlHsApps pure_RDR [nlHsApp coerce_Expr z_Expr])]+ traverse_match_ctxt = mkPrefixFunRhs traverse_name++gen_Traversable_binds loc tycon+ = (unitBag traverse_bind, emptyBag)+ where data_cons = tyConDataCons tycon - traverse_bind = mkRdrFunBind (L loc traverse_RDR) eqns- eqns = map traverse_eqn data_cons+ traverse_name = L loc traverse_RDR++ -- See Note [EmptyDataDecls with Functor, Foldable, and Traversable]+ traverse_bind = mkRdrFunBindEC 2 (nlHsApp pure_Expr)+ traverse_name traverse_eqns+ traverse_eqns = map traverse_eqn data_cons traverse_eqn con = evalState (match_for_con [f_Pat] con =<< parts) bs_RDRs where@@ -729,7 +901,7 @@ -- Yields 'Just' an expression if we're folding over a type that mentions -- the last type parameter of the datatype. Otherwise, yields 'Nothing'. -- See Note [FFoldType and functorLikeTraverse]- ft_trav :: FFoldType (State [RdrName] (Maybe (LHsExpr RdrName)))+ ft_trav :: FFoldType (State [RdrName] (Maybe (LHsExpr GhcPs))) ft_trav = FT { ft_triv = return Nothing -- traverse f = pure x@@ -744,21 +916,21 @@ , ft_ty_app = \_ g -> fmap (nlHsApp traverse_Expr) <$> g -- traverse f = traverse g , ft_forall = \_ g -> g- , ft_co_var = panic "contravariant"- , ft_fun = panic "function"- , ft_bad_app = panic "in other argument" }+ , ft_co_var = panic "contravariant in ft_trav"+ , ft_fun = panic "function in ft_trav"+ , ft_bad_app = panic "in other argument in ft_trav" } -- Con a1 a2 ... -> liftA2 (\b1 b2 ... -> Con b1 b2 ...) (g1 a1) -- (g2 a2) <*> ...- match_for_con :: [LPat RdrName]+ match_for_con :: [LPat GhcPs] -> DataCon- -> [Maybe (LHsExpr RdrName)]- -> State [RdrName] (LMatch RdrName (LHsExpr RdrName))+ -> [Maybe (LHsExpr GhcPs)]+ -> State [RdrName] (LMatch GhcPs (LHsExpr GhcPs)) match_for_con = mkSimpleConMatch2 CaseAlt $ \con xs -> return (mkApCon con xs) where -- liftA2 (\b1 b2 ... -> Con b1 b2 ...) x1 x2 <*> ..- mkApCon :: LHsExpr RdrName -> [LHsExpr RdrName] -> LHsExpr RdrName+ mkApCon :: LHsExpr GhcPs -> [LHsExpr GhcPs] -> LHsExpr GhcPs mkApCon con [] = nlHsApps pure_RDR [con] mkApCon con [x] = nlHsApps fmap_RDR [con,x] mkApCon con (x1:x2:xs) =@@ -768,7 +940,8 @@ ----------------------------------------------------------------------- f_Expr, z_Expr, fmap_Expr, replace_Expr, mempty_Expr, foldMap_Expr,- traverse_Expr :: LHsExpr RdrName+ traverse_Expr, coerce_Expr, pure_Expr, true_Expr, false_Expr,+ all_Expr, null_Expr :: LHsExpr GhcPs f_Expr = nlHsVar f_RDR z_Expr = nlHsVar z_RDR fmap_Expr = nlHsVar fmap_RDR@@ -776,6 +949,12 @@ mempty_Expr = nlHsVar mempty_RDR foldMap_Expr = nlHsVar foldMap_RDR traverse_Expr = nlHsVar traverse_RDR+coerce_Expr = nlHsVar (getRdrName coerceId)+pure_Expr = nlHsVar pure_RDR+true_Expr = nlHsVar true_RDR+false_Expr = nlHsVar false_RDR+all_Expr = nlHsVar all_RDR+null_Expr = nlHsVar null_RDR f_RDR, z_RDR :: RdrName f_RDR = mkVarUnqual (fsLit "f")@@ -785,7 +964,11 @@ as_RDRs = [ mkVarUnqual (mkFastString ("a"++show i)) | i <- [(1::Int) .. ] ] bs_RDRs = [ mkVarUnqual (mkFastString ("b"++show i)) | i <- [(1::Int) .. ] ] -f_Pat, z_Pat :: LPat RdrName+as_Vars, bs_Vars :: [LHsExpr GhcPs]+as_Vars = map nlHsVar as_RDRs+bs_Vars = map nlHsVar bs_RDRs++f_Pat, z_Pat :: LPat GhcPs f_Pat = nlVarPat f_RDR z_Pat = nlVarPat z_RDR @@ -859,7 +1042,7 @@ Only E1's argument is an occurrence of a universally quantified type variable that is syntactically equivalent to the last type parameter, so only E1's-argument will be be folded over in a derived Foldable instance.+argument will be folded over in a derived Foldable instance. See Trac #10447 for the original discussion on this feature. Also see https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/DeriveFunctor@@ -1020,4 +1203,84 @@ which does not typecheck, since GHC cannot unify the rank-2 type variables in the types of b and (fmap f a).++Note [Phantom types with Functor, Foldable, and Traversable]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++Given a type F :: * -> * whose type argument has a phantom role, we can always+produce lawful Functor and Traversable instances using++ fmap _ = coerce+ traverse _ = pure . coerce++Indeed, these are equivalent to any *strictly lawful* instances one could+write, except that this definition of 'traverse' may be lazier. That is, if+instances obey the laws under true equality (rather than up to some equivalence+relation), then they will be essentially equivalent to these. These definitions+are incredibly cheap, so we want to use them even if it means ignoring some+non-strictly-lawful instance in an embedded type.++Foldable has far fewer laws to work with, which leaves us unwelcome+freedom in implementing it. At a minimum, we would like to ensure that+a derived foldMap is always at least as good as foldMapDefault with a+derived traverse. To accomplish that, we must define++ foldMap _ _ = mempty++in these cases.++This may have different strictness properties from a standard derivation.+Consider++ data NotAList a = Nil | Cons (NotAList a) deriving Foldable++The usual deriving mechanism would produce++ foldMap _ Nil = mempty+ foldMap f (Cons x) = foldMap f x++which is strict in the entire spine of the NotAList.++Final point: why do we even care about such types? Users will rarely if ever+map, fold, or traverse over such things themselves, but other derived+instances may:++ data Hasn'tAList a = NotHere a (NotAList a) deriving Foldable++Note [EmptyDataDecls with Functor, Foldable, and Traversable]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++There are some slightly tricky decisions to make about how to handle+Functor, Foldable, and Traversable instances for types with no constructors.+For fmap, the two basic options are++ fmap _ _ = error "Sorry, no constructors"++or++ fmap _ z = case z of++In most cases, the latter is more helpful: if the thunk passed to fmap+throws an exception, we're generally going to be much more interested in+that exception than in the fact that there aren't any constructors.++In order to match the semantics for phantoms (see note above), we need to+be a bit careful about 'traverse'. The obvious definition would be++ traverse _ z = case z of++but this is stricter than the one for phantoms. We instead use++ traverse _ z = pure $ case z of++For foldMap, the obvious choices are++ foldMap _ _ = mempty++or++ foldMap _ z = case z of++We choose the first one to be consistent with what foldMapDefault does for+a derived Traversable instance. -}
typecheck/TcGenGenerics.hs view
@@ -8,11 +8,14 @@ {-# LANGUAGE CPP, ScopedTypeVariables, TupleSections #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-} module TcGenGenerics (canDoGenerics, canDoGenerics1, GenericKind(..), gen_Generic_binds, get_gen1_constrained_tys) where +import GhcPrelude+ import HsSyn import Type import TcType@@ -65,7 +68,7 @@ -} gen_Generic_binds :: GenericKind -> TyCon -> [Type]- -> TcM (LHsBinds RdrName, FamInst)+ -> TcM (LHsBinds GhcPs, FamInst) gen_Generic_binds gk tc inst_tys = do repTyInsts <- tc_mkRepFamInsts gk tc inst_tys return (mkBindsRep gk tc, repTyInsts)@@ -296,7 +299,7 @@ -} type US = Int -- Local unique supply, just a plain Int-type Alt = (LPat RdrName, LHsExpr RdrName)+type Alt = (LPat GhcPs, LHsExpr GhcPs) -- GenericKind serves to mark if a datatype derives Generic (Gen0) or -- Generic1 (Gen1).@@ -320,7 +323,7 @@ -- Bindings for the Generic instance-mkBindsRep :: GenericKind -> TyCon -> LHsBinds RdrName+mkBindsRep :: GenericKind -> TyCon -> LHsBinds GhcPs mkBindsRep gk tycon = unitBag (mkRdrFunBind (L loc from01_RDR) [from_eqn]) `unionBags`@@ -345,10 +348,10 @@ -- Recurse over the sum first from_alts, to_alts :: [Alt]- (from_alts, to_alts) = mkSum gk_ (1 :: US) tycon datacons+ (from_alts, to_alts) = mkSum gk_ (1 :: US) datacons where gk_ = case gk of Gen0 -> Gen0_- Gen1 -> ASSERT(length tyvars >= 1)+ Gen1 -> ASSERT(tyvars `lengthAtLeast` 1) Gen1_ (last tyvars) where tyvars = tyConTyVars tycon @@ -572,7 +575,7 @@ prod :: [Type] -> [HsSrcBang] -> [HsImplBang] -> [FieldLabel] -> Type prod [] _ _ _ = mkTyConApp u1 [k] prod l sb ib fl = foldBal mkProd- [ ASSERT(null fl || length fl > j)+ [ ASSERT(null fl || lengthExceeds fl j) arg t sb' ib' (if null fl then Nothing else Just (fl !! j))@@ -617,7 +620,7 @@ buildFix n assoc = mkTyConApp pInfix [ mkTyConTy assoc , mkNumLitTy (fromIntegral n)] - isRec c = mkTyConTy $ if length (dataConFieldLabels c) > 0+ isRec c = mkTyConTy $ if dataConFieldLabels c `lengthExceeds` 0 then promotedTrueDataCon else promotedFalseDataCon @@ -693,24 +696,19 @@ mkSum :: GenericKind_ -- Generic or Generic1? -> US -- Base for generating unique names- -> TyCon -- The type constructor -> [DataCon] -- The data constructors -> ([Alt], -- Alternatives for the T->Trep "from" function [Alt]) -- Alternatives for the Trep->T "to" function -- Datatype without any constructors-mkSum _ _ tycon [] = ([from_alt], [to_alt])+mkSum _ _ [] = ([from_alt], [to_alt]) where- from_alt = (nlWildPat, makeError errMsgFrom)- to_alt = (nlWildPat, makeError errMsgTo)+ from_alt = (x_Pat, nlHsCase x_Expr [])+ to_alt = (x_Pat, nlHsCase x_Expr []) -- These M1s are meta-information for the datatype- makeError s = nlHsApp (nlHsVar error_RDR) (nlHsLit (mkHsString s))- tyConStr = occNameString (nameOccName (tyConName tycon))- errMsgFrom = "No generic representation for empty datatype " ++ tyConStr- errMsgTo = "No values for empty datatype " ++ tyConStr -- Datatype with at least one constructor-mkSum gk_ us _ datacons =+mkSum gk_ us datacons = -- switch the payload of gk_ to be datacon-centric instead of tycon-centric unzip [ mk1Sum (gk2gkDC gk_ d) us i (length datacons) d | (d,i) <- zip datacons [1..] ]@@ -757,7 +755,7 @@ -- Generates the L1/R1 sum pattern-genLR_P :: Int -> Int -> LPat RdrName -> LPat RdrName+genLR_P :: Int -> Int -> LPat GhcPs -> LPat GhcPs genLR_P i n p | n == 0 = error "impossible" | n == 1 = p@@ -766,7 +764,7 @@ where m = div n 2 -- Generates the L1/R1 sum expression-genLR_E :: Int -> Int -> LHsExpr RdrName -> LHsExpr RdrName+genLR_E :: Int -> Int -> LHsExpr GhcPs -> LHsExpr GhcPs genLR_E i n e | n == 0 = error "impossible" | n == 1 = e@@ -783,8 +781,9 @@ -- Build a product expression mkProd_E :: GenericKind_DC -- Generic or Generic1? -> US -- Base for unique names- -> [(RdrName, Type)] -- List of variables matched on the lhs and their types- -> LHsExpr RdrName -- Resulting product expression+ -> [(RdrName, Type)]+ -- List of variables matched on the lhs and their types+ -> LHsExpr GhcPs -- Resulting product expression mkProd_E _ _ [] = mkM1_E (nlHsVar u1DataCon_RDR) mkProd_E gk_ _ varTys = mkM1_E (foldBal prod appVars) -- These M1s are meta-information for the constructor@@ -792,7 +791,7 @@ appVars = map (wrapArg_E gk_) varTys prod a b = prodDataCon_RDR `nlHsApps` [a,b] -wrapArg_E :: GenericKind_DC -> (RdrName, Type) -> LHsExpr RdrName+wrapArg_E :: GenericKind_DC -> (RdrName, Type) -> LHsExpr GhcPs wrapArg_E Gen0_DC (var, ty) = mkM1_E $ boxRepRDR ty `nlHsVarApps` [var] -- This M1 is meta-information for the selector@@ -829,7 +828,7 @@ -> US -- Base for unique names -> [(RdrName, Type)] -- List of variables to match, -- along with their types- -> LPat RdrName -- Resulting product pattern+ -> LPat GhcPs -- Resulting product pattern mkProd_P _ _ [] = mkM1_P (nlNullaryConPat u1DataCon_RDR) mkProd_P gk _ varTys = mkM1_P (foldBal prod appVars) -- These M1s are meta-information for the constructor@@ -837,7 +836,7 @@ appVars = unzipWith (wrapArg_P gk) varTys prod a b = nlParPat $ prodDataCon_RDR `nlConPat` [a,b] -wrapArg_P :: GenericKind -> RdrName -> Type -> LPat RdrName+wrapArg_P :: GenericKind -> RdrName -> Type -> LPat GhcPs wrapArg_P Gen0 v ty = mkM1_P (nlParPat $ boxRepRDR ty `nlConVarPat` [v]) -- This M1 is meta-information for the selector wrapArg_P Gen1 v _ = nlParPat $ m1DataCon_RDR `nlConVarPat` [v]@@ -848,19 +847,19 @@ x_RDR :: RdrName x_RDR = mkVarUnqual (fsLit "x") -x_Expr :: LHsExpr RdrName+x_Expr :: LHsExpr GhcPs x_Expr = nlHsVar x_RDR -x_Pat :: LPat RdrName+x_Pat :: LPat GhcPs x_Pat = nlVarPat x_RDR -mkM1_E :: LHsExpr RdrName -> LHsExpr RdrName+mkM1_E :: LHsExpr GhcPs -> LHsExpr GhcPs mkM1_E e = nlHsVar m1DataCon_RDR `nlHsApp` e -mkM1_P :: LPat RdrName -> LPat RdrName+mkM1_P :: LPat GhcPs -> LPat GhcPs mkM1_P p = nlParPat $ m1DataCon_RDR `nlConPat` [p] -nlHsCompose :: LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName+nlHsCompose :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs nlHsCompose x y = compose_RDR `nlHsApps` [x, y] -- | Variant of foldr1 for producing balanced lists
typecheck/TcHsSyn.hs view
file too large to diff
typecheck/TcHsType.hs view
file too large to diff
typecheck/TcInstDcls.hs view
file too large to diff
typecheck/TcInstDcls.hs-boot view
file too large to diff
typecheck/TcInteract.hs view
file too large to diff
typecheck/TcMType.hs view
file too large to diff
typecheck/TcMatches.hs view
file too large to diff
typecheck/TcMatches.hs-boot view
file too large to diff
typecheck/TcPat.hs view
file too large to diff
typecheck/TcPatSyn.hs view
file too large to diff
typecheck/TcPatSyn.hs-boot view
file too large to diff
typecheck/TcPluginM.hs view
file too large to diff
typecheck/TcRnDriver.hs view
file too large to diff
typecheck/TcRnDriver.hs-boot view
file too large to diff
typecheck/TcRnExports.hs view
file too large to diff
typecheck/TcRnMonad.hs view
file too large to diff
typecheck/TcRnTypes.hs view
file too large to diff
typecheck/TcRules.hs view
file too large to diff
typecheck/TcSMonad.hs view
file too large to diff
typecheck/TcSigs.hs view
file too large to diff
typecheck/TcSimplify.hs view
file too large to diff
+ typecheck/TcSimplify.hs-boot view
file too large to diff
typecheck/TcSplice.hs view
file too large to diff
typecheck/TcSplice.hs-boot view
file too large to diff
typecheck/TcTyClsDecls.hs view
file too large to diff
typecheck/TcTyDecls.hs view
file too large to diff
typecheck/TcType.hs view
file too large to diff
typecheck/TcTypeNats.hs view
file too large to diff
typecheck/TcTypeable.hs view
file too large to diff
typecheck/TcUnify.hs view
file too large to diff
typecheck/TcUnify.hs-boot view
file too large to diff
typecheck/TcValidity.hs view
file too large to diff
types/Class.hs view
file too large to diff
types/CoAxiom.hs view
file too large to diff
types/Coercion.hs view
file too large to diff
types/Coercion.hs-boot view
file too large to diff
types/FamInstEnv.hs view
file too large to diff
types/InstEnv.hs view
file too large to diff
types/Kind.hs view
file too large to diff
types/OptCoercion.hs view
file too large to diff
types/TyCoRep.hs view
file too large to diff
types/TyCon.hs view
file too large to diff
types/TyCon.hs-boot view
file too large to diff
types/Type.hs view
file too large to diff
types/Type.hs-boot view
file too large to diff
types/Unify.hs view
file too large to diff
+ utils/AsmUtils.hs view
file too large to diff
utils/Bag.hs view
file too large to diff
utils/Binary.hs view
file too large to diff
utils/BooleanFormula.hs view
file too large to diff
utils/BufWrite.hs view
file too large to diff
utils/Digraph.hs view
file too large to diff
utils/Encoding.hs view
file too large to diff
+ utils/EnumSet.hs view
file too large to diff
utils/Exception.hs view
file too large to diff
utils/FV.hs view
file too large to diff
utils/FastFunctions.hs view
file too large to diff
utils/FastMutInt.hs view
file too large to diff
utils/FastString.hs view
file too large to diff
utils/FastStringEnv.hs view
file too large to diff
utils/Fingerprint.hsc view
file too large to diff
utils/FiniteMap.hs view
file too large to diff
+ utils/GhcPrelude.hs view
file too large to diff
utils/GraphBase.hs view
file too large to diff
utils/GraphColor.hs view
file too large to diff
utils/GraphOps.hs view
file too large to diff
utils/GraphPpr.hs view
file too large to diff
utils/IOEnv.hs view
file too large to diff
utils/Json.hs view
file too large to diff
utils/ListSetOps.hs view
file too large to diff
utils/ListT.hs view
file too large to diff
utils/Maybes.hs view
file too large to diff
utils/MonadUtils.hs view
file too large to diff
utils/OrdList.hs view
file too large to diff
utils/Outputable.hs view
file too large to diff
utils/Outputable.hs-boot view
file too large to diff
utils/Pair.hs view
file too large to diff
utils/Panic.hs view
file too large to diff
utils/Platform.hs view
file too large to diff
utils/PprColour.hs view
file too large to diff
utils/Pretty.hs view
file too large to diff
utils/State.hs view
file too large to diff
utils/Stream.hs view
file too large to diff
utils/StringBuffer.hs view
file too large to diff
utils/UnVarGraph.hs view
file too large to diff
utils/UniqDFM.hs view
file too large to diff
utils/UniqDSet.hs view
file too large to diff
utils/UniqFM.hs view
file too large to diff
+ utils/UniqMap.hs view
file too large to diff
utils/UniqSet.hs view
file too large to diff
utils/Util.hs view
file too large to diff
utils/md5.h view
file too large to diff
vectorise/Vectorise.hs view
file too large to diff
vectorise/Vectorise/Builtins/Base.hs view
file too large to diff
vectorise/Vectorise/Builtins/Initialise.hs view
file too large to diff
vectorise/Vectorise/Convert.hs view
file too large to diff
vectorise/Vectorise/Env.hs view
file too large to diff
vectorise/Vectorise/Exp.hs view
file too large to diff
vectorise/Vectorise/Generic/Description.hs view
file too large to diff
vectorise/Vectorise/Generic/PADict.hs view
file too large to diff
vectorise/Vectorise/Generic/PAMethods.hs view
file too large to diff
vectorise/Vectorise/Generic/PData.hs view
file too large to diff
vectorise/Vectorise/Monad.hs view
file too large to diff
vectorise/Vectorise/Monad/Base.hs view
file too large to diff
vectorise/Vectorise/Monad/Global.hs view
file too large to diff
vectorise/Vectorise/Monad/InstEnv.hs view
file too large to diff
vectorise/Vectorise/Monad/Local.hs view
file too large to diff
vectorise/Vectorise/Monad/Naming.hs view
file too large to diff
vectorise/Vectorise/Type/Classify.hs view
file too large to diff
vectorise/Vectorise/Type/Env.hs view
file too large to diff
vectorise/Vectorise/Type/TyConDecl.hs view
file too large to diff
vectorise/Vectorise/Type/Type.hs view
file too large to diff
vectorise/Vectorise/Utils.hs view
file too large to diff
vectorise/Vectorise/Utils/Base.hs view
file too large to diff
vectorise/Vectorise/Utils/Closure.hs view
file too large to diff
vectorise/Vectorise/Utils/Hoisting.hs view
file too large to diff
vectorise/Vectorise/Utils/PADict.hs view
file too large to diff
vectorise/Vectorise/Utils/Poly.hs view
file too large to diff
vectorise/Vectorise/Var.hs view
file too large to diff
vectorise/Vectorise/Vect.hs view
file too large to diff